svn merge -r 37306:39975 https://svn.blender.org/svnroot/bf-blender/trunk/blender

136 files changed, 3937 insertions, 2486 deletions

diff --git a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
index cac801c80ef..40f1701e44a 100644
--- a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
+++ b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
@@ -95,8 +95,6 @@ extern float BKE_screen_view3d_zoom_to_fac(float camzoom);
 #include "BKE_ipo.h"
 	/***/
 
-#include "AUD_C-API.h"
-
 //XXX #include "BSE_headerbuttons.h"
 #include "BKE_context.h"
 #include "../../blender/windowmanager/WM_types.h"
@@ -106,6 +104,11 @@ extern float BKE_screen_view3d_zoom_to_fac(float camzoom);
 }
 #endif
 
+#ifdef WITH_AUDASPACE
+#  include "AUD_C-API.h"
+#  include "AUD_I3DDevice.h"
+#  include "AUD_IDevice.h"
+#endif
 
 static BlendFileData *load_game_data(char *filename)
 {
@@ -184,6 +187,7 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
 #endif
 		bool novertexarrays = (SYS_GetCommandLineInt(syshandle, "novertexarrays", 0) != 0);
 		bool mouse_state = startscene->gm.flag & GAME_SHOW_MOUSE;
+		bool restrictAnimFPS = startscene->gm.flag & GAME_RESTRICT_ANIM_UPDATES;
 
 		if(animation_record) usefixed= true; /* override since you's always want fixed time for sim recording */
 
@@ -231,9 +235,9 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
 		ketsjiengine->SetCanvas(canvas);
 		ketsjiengine->SetRenderTools(rendertools);
 		ketsjiengine->SetRasterizer(rasterizer);
-		ketsjiengine->SetNetworkDevice(networkdevice);
 		ketsjiengine->SetUseFixedTime(usefixed);
 		ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
+		ketsjiengine->SetRestrictAnimationFPS(restrictAnimFPS);
 
 #ifdef WITH_PYTHON
 		CValue::SetDeprecationWarnings(nodepwarnings);
@@ -258,7 +262,7 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
 				draw_letterbox = 1;
 			}
 			else {
-				camzoom = BKE_screen_view3d_zoom_to_fac(rv3d->camzoom)*4.0f;
+				camzoom = 1.0 / BKE_screen_view3d_zoom_to_fac(rv3d->camzoom);
 			}
 		}
 		else {
@@ -392,9 +396,13 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
 				ketsjiengine->InitDome(scene->gm.dome.res, scene->gm.dome.mode, scene->gm.dome.angle, scene->gm.dome.resbuf, scene->gm.dome.tilt, scene->gm.dome.warptext);
 
 			// initialize 3D Audio Settings
-			AUD_setSpeedOfSound(scene->audio.speed_of_sound);
-			AUD_setDopplerFactor(scene->audio.doppler_factor);
-			AUD_setDistanceModel(AUD_DistanceModel(scene->audio.distance_model));
+			AUD_I3DDevice* dev = AUD_get3DDevice();
+			if(dev)
+			{
+				dev->setSpeedOfSound(scene->audio.speed_of_sound);
+				dev->setDopplerFactor(scene->audio.doppler_factor);
+				dev->setDistanceModel(AUD_DistanceModel(scene->audio.distance_model));
+			}
 
 			// from see blender.c:
 			// FIXME: this version patching should really be part of the file-reading code,
@@ -579,7 +587,10 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
 		{
 			delete canvas;
 			canvas = NULL;
-                }
+		}
+
+		// stop all remaining playing sounds
+		AUD_getDevice()->stopAll();
 	
 	} while (exitrequested == KX_EXIT_REQUEST_RESTART_GAME || exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME);
 	
diff --git a/source/gameengine/BlenderRoutines/CMakeLists.txt b/source/gameengine/BlenderRoutines/CMakeLists.txt
index a67e2eb7038..5a7304765e4 100644
--- a/source/gameengine/BlenderRoutines/CMakeLists.txt
+++ b/source/gameengine/BlenderRoutines/CMakeLists.txt
@@ -1,34 +1,33 @@
 
 set(INC
 	.
-	../../../intern/string
+	../Converter
+	../Expressions
+	../GameLogic
+	../Ketsji
+	../Network
+	../Network/LoopBackNetwork
+	../Physics/Bullet
+	../Physics/common
+	../Rasterizer
+	../Rasterizer/RAS_OpenGLRasterizer
+	../SceneGraph
+	../../blender
+	../../blender/blenfont
+	../../blender/blenkernel
+	../../blender/blenlib
+	../../blender/blenloader
+	../../blender/editors/include
+	../../blender/gpu
+	../../blender/imbuf
+	../../blender/makesdna
+	../../blender/makesrna
+	../../blender/windowmanager
+	../../../extern/bullet2/src
 	../../../intern/container
 	../../../intern/guardedalloc
-	../../../intern/audaspace/intern
-	../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer 
-	../../../source/gameengine/Converter
-	../../../source/blender/imbuf
 	../../../intern/moto/include
-	../../../source/gameengine/Ketsji 
-	../../../source/blender/blenlib
-	../../../source/blender/blenkernel 
-	../../../source/blender/blenfont
-	../../../source/blender/editors/include
-	../../../source/blender/windowmanager
-	../../../source/blender
-	../../../source/blender/makesdna
-	../../../source/blender/makesrna 
-	../../../source/gameengine/Rasterizer 
-	../../../source/gameengine/GameLogic
-	../../../source/gameengine/Expressions 
-	../../../source/gameengine/Network
-	../../../source/gameengine/SceneGraph 
-	../../../source/gameengine/Physics/common
-	../../../source/gameengine/Physics/Bullet
-	../../../source/gameengine/Network/LoopBackNetwork
-	../../../source/blender/blenloader
-	../../../source/blender/gpu
-	../../../extern/bullet2/src
+	../../../intern/string
 	${GLEW_INCLUDE_PATH}
 )
 
@@ -59,6 +58,13 @@ set(SRC
 
 add_definitions(-DGLEW_STATIC)
 
+if(WITH_AUDASPACE)
+	list(APPEND INC
+		../../../intern/audaspace/intern
+	)
+	add_definitions(-DWITH_AUDASPACE)
+endif()
+
 if(WITH_CODEC_FFMPEG)
 	add_definitions(-DWITH_FFMPEG)
 endif()
diff --git a/source/gameengine/BlenderRoutines/KX_BlenderInputDevice.h b/source/gameengine/BlenderRoutines/KX_BlenderInputDevice.h
index 67a2279d824..7e9a57a0fe7 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderInputDevice.h
+++ b/source/gameengine/BlenderRoutines/KX_BlenderInputDevice.h
@@ -51,197 +51,195 @@
 /**
  Base Class for Blender specific inputdevices. Blender specific inputdevices are used when the gameengine is running in embedded mode instead of standalone mode.
 */
-class BL_BlenderInputDevice : public SCA_IInputDevice                                                               
+class BL_BlenderInputDevice : public SCA_IInputDevice
 {
 	// this map is Blender specific: a conversion between blender and ketsji enums
 	std::map<int,KX_EnumInputs> m_reverseKeyTranslateTable;
 public:
-	BL_BlenderInputDevice()                                                                                    
-		{                                                                                                          
-			
-			/* The reverse table. In order to not confuse ourselves, we      */
-			/* immediately convert all events that come in to KX codes.      */
-			m_reverseKeyTranslateTable[LEFTMOUSE			] =	KX_LEFTMOUSE		;
-			m_reverseKeyTranslateTable[MIDDLEMOUSE			] =	KX_MIDDLEMOUSE		;
-			m_reverseKeyTranslateTable[RIGHTMOUSE			] =	KX_RIGHTMOUSE		;
-			m_reverseKeyTranslateTable[WHEELUPMOUSE			] =	KX_WHEELUPMOUSE		;
-			m_reverseKeyTranslateTable[WHEELDOWNMOUSE		] =	KX_WHEELDOWNMOUSE	;
-			m_reverseKeyTranslateTable[MOUSEX			] =	KX_MOUSEX		;
-			m_reverseKeyTranslateTable[MOUSEY			] =	KX_MOUSEY		;
-                                                                                                                   
-			// TIMERS                                                                                                  
-
-			m_reverseKeyTranslateTable[TIMER0                           ] =	KX_TIMER0                  ;                  
-			m_reverseKeyTranslateTable[TIMER1                           ] =	KX_TIMER1                  ;                  
-			m_reverseKeyTranslateTable[TIMER2                           ] = KX_TIMER2                  ;                  
-                                                                                                                   
-			// SYSTEM 
-#if 0			
-			/* **** XXX **** */
-			m_reverseKeyTranslateTable[KEYBD                            ] = KX_KEYBD                   ;                  
-			m_reverseKeyTranslateTable[RAWKEYBD                         ] = KX_RAWKEYBD                ;                  
-			m_reverseKeyTranslateTable[REDRAW                           ] = KX_REDRAW                  ;                  
-			m_reverseKeyTranslateTable[INPUTCHANGE                      ] = KX_INPUTCHANGE             ;                  
-			m_reverseKeyTranslateTable[QFULL                            ] = KX_QFULL                   ;                  
-			m_reverseKeyTranslateTable[WINFREEZE                        ] = KX_WINFREEZE               ;                  
-			m_reverseKeyTranslateTable[WINTHAW                          ] = KX_WINTHAW                 ;                  
-			m_reverseKeyTranslateTable[WINCLOSE                         ] = KX_WINCLOSE                ;                  
-			m_reverseKeyTranslateTable[WINQUIT                          ] = KX_WINQUIT                 ;                  
-			m_reverseKeyTranslateTable[Q_FIRSTTIME                      ] = KX_Q_FIRSTTIME             ;                  
-			/* **** XXX **** */
-#endif                                                                                                                   
-			// standard keyboard                                                                                       
-                                                                                                                   
-			m_reverseKeyTranslateTable[AKEY                             ] = KX_AKEY                    ;                  
-			m_reverseKeyTranslateTable[BKEY                             ] = KX_BKEY                    ;                  
-			m_reverseKeyTranslateTable[CKEY                             ] = KX_CKEY                    ;                  
-			m_reverseKeyTranslateTable[DKEY                             ] = KX_DKEY                    ;                  
-			m_reverseKeyTranslateTable[EKEY                             ] = KX_EKEY                    ;                  
-			m_reverseKeyTranslateTable[FKEY                             ] = KX_FKEY                    ;                  
-			m_reverseKeyTranslateTable[GKEY                             ] = KX_GKEY                    ;                  
-//XXX clean up
+	BL_BlenderInputDevice()
+	{
+
+		/* The reverse table. In order to not confuse ourselves, we      */
+		/* immediately convert all events that come in to KX codes.      */
+		m_reverseKeyTranslateTable[LEFTMOUSE			] =	KX_LEFTMOUSE;
+		m_reverseKeyTranslateTable[MIDDLEMOUSE			] =	KX_MIDDLEMOUSE;
+		m_reverseKeyTranslateTable[RIGHTMOUSE			] =	KX_RIGHTMOUSE;
+		m_reverseKeyTranslateTable[WHEELUPMOUSE			] =	KX_WHEELUPMOUSE;
+		m_reverseKeyTranslateTable[WHEELDOWNMOUSE		] =	KX_WHEELDOWNMOUSE;
+		m_reverseKeyTranslateTable[MOUSEX			] =	KX_MOUSEX;
+		m_reverseKeyTranslateTable[MOUSEY			] =	KX_MOUSEY;
+
+		// TIMERS
+
+		m_reverseKeyTranslateTable[TIMER0                           ] =	KX_TIMER0;
+		m_reverseKeyTranslateTable[TIMER1                           ] =	KX_TIMER1;
+		m_reverseKeyTranslateTable[TIMER2                           ] = KX_TIMER2;
+
+		// SYSTEM
+#if 0
+		/* **** XXX **** */
+		m_reverseKeyTranslateTable[KEYBD                            ] = KX_KEYBD;
+		m_reverseKeyTranslateTable[RAWKEYBD                         ] = KX_RAWKEYBD;
+		m_reverseKeyTranslateTable[REDRAW                           ] = KX_REDRAW;
+		m_reverseKeyTranslateTable[INPUTCHANGE                      ] = KX_INPUTCHANGE;
+		m_reverseKeyTranslateTable[QFULL                            ] = KX_QFULL;
+		m_reverseKeyTranslateTable[WINFREEZE                        ] = KX_WINFREEZE;
+		m_reverseKeyTranslateTable[WINTHAW                          ] = KX_WINTHAW;
+		m_reverseKeyTranslateTable[WINCLOSE                         ] = KX_WINCLOSE;
+		m_reverseKeyTranslateTable[WINQUIT                          ] = KX_WINQUIT;
+		m_reverseKeyTranslateTable[Q_FIRSTTIME                      ] = KX_Q_FIRSTTIME;
+		/* **** XXX **** */
+#endif
+		// standard keyboard
+
+		m_reverseKeyTranslateTable[AKEY                             ] = KX_AKEY;
+		m_reverseKeyTranslateTable[BKEY                             ] = KX_BKEY;
+		m_reverseKeyTranslateTable[CKEY                             ] = KX_CKEY;
+		m_reverseKeyTranslateTable[DKEY                             ] = KX_DKEY;
+		m_reverseKeyTranslateTable[EKEY                             ] = KX_EKEY;
+		m_reverseKeyTranslateTable[FKEY                             ] = KX_FKEY;
+		m_reverseKeyTranslateTable[GKEY                             ] = KX_GKEY;
+		//XXX clean up
 #ifdef WIN32
 #define HKEY	'h'
 #endif
-			m_reverseKeyTranslateTable[HKEY                             ] = KX_HKEY                    ;                  
-//XXX clean up
+		m_reverseKeyTranslateTable[HKEY                             ] = KX_HKEY;
+		//XXX clean up
 #ifdef WIN32
 #undef HKEY
 #endif
-			m_reverseKeyTranslateTable[IKEY                             ] = KX_IKEY                    ;                  
-			m_reverseKeyTranslateTable[JKEY                             ] = KX_JKEY                    ;                  
-			m_reverseKeyTranslateTable[KKEY                             ] = KX_KKEY                    ;                  
-			m_reverseKeyTranslateTable[LKEY                             ] = KX_LKEY                    ;                  
-			m_reverseKeyTranslateTable[MKEY                             ] = KX_MKEY                    ;                  
-			m_reverseKeyTranslateTable[NKEY                             ] = KX_NKEY                    ;                  
-			m_reverseKeyTranslateTable[OKEY                             ] = KX_OKEY                    ;                  
-			m_reverseKeyTranslateTable[PKEY                             ] = KX_PKEY                    ;                  
-			m_reverseKeyTranslateTable[QKEY                             ] = KX_QKEY                    ;                  
-			m_reverseKeyTranslateTable[RKEY                             ] = KX_RKEY                    ;                  
-			m_reverseKeyTranslateTable[SKEY                             ] = KX_SKEY                    ;                  
-			m_reverseKeyTranslateTable[TKEY                             ] =	KX_TKEY                    ;                  
-			m_reverseKeyTranslateTable[UKEY                             ] = KX_UKEY                    ;                  
-			m_reverseKeyTranslateTable[VKEY                             ] = KX_VKEY                    ;                  
-			m_reverseKeyTranslateTable[WKEY                             ] = KX_WKEY                    ;                  
-			m_reverseKeyTranslateTable[XKEY                             ] = KX_XKEY                    ;                  
-			m_reverseKeyTranslateTable[YKEY                             ] = KX_YKEY                    ;                  
-			m_reverseKeyTranslateTable[ZKEY                             ] = KX_ZKEY                    ;                  
-                                                                                                                   
-			m_reverseKeyTranslateTable[ZEROKEY		                ] = KX_ZEROKEY		        ;                  
-			m_reverseKeyTranslateTable[ONEKEY		                ] = KX_ONEKEY		        ;                  
-			m_reverseKeyTranslateTable[TWOKEY		                ] = KX_TWOKEY		        ;                  
-			m_reverseKeyTranslateTable[THREEKEY                     ] = KX_THREEKEY                ;                  
-			m_reverseKeyTranslateTable[FOURKEY		                ] = KX_FOURKEY		        ;                  
-			m_reverseKeyTranslateTable[FIVEKEY		                ] = KX_FIVEKEY		        ;                  
-			m_reverseKeyTranslateTable[SIXKEY		                ] = KX_SIXKEY		        ;                  
-			m_reverseKeyTranslateTable[SEVENKEY                         ] = KX_SEVENKEY                ;                  
-			m_reverseKeyTranslateTable[EIGHTKEY                         ] = KX_EIGHTKEY                ;                  
-			m_reverseKeyTranslateTable[NINEKEY		                ] = KX_NINEKEY		        ;                  
-	                                                                                                           
-			m_reverseKeyTranslateTable[CAPSLOCKKEY                      ] = KX_CAPSLOCKKEY             ;                  
-	                                                        
-			m_reverseKeyTranslateTable[LEFTCTRLKEY	                ] = KX_LEFTCTRLKEY	        ;                  
-			m_reverseKeyTranslateTable[LEFTALTKEY 		        ] = KX_LEFTALTKEY 		;                  
-			m_reverseKeyTranslateTable[RIGHTALTKEY 	                ] = KX_RIGHTALTKEY 	        ;                  
-			m_reverseKeyTranslateTable[RIGHTCTRLKEY 	                ] = KX_RIGHTCTRLKEY 	        ;                  
-			m_reverseKeyTranslateTable[RIGHTSHIFTKEY	                ] = KX_RIGHTSHIFTKEY	        ;                  
-			m_reverseKeyTranslateTable[LEFTSHIFTKEY                     ] = KX_LEFTSHIFTKEY            ;                  
-	                                                                                                           
-			m_reverseKeyTranslateTable[ESCKEY                           ] = KX_ESCKEY                  ;                  
-			m_reverseKeyTranslateTable[TABKEY                           ] = KX_TABKEY                  ;                  
-			m_reverseKeyTranslateTable[RETKEY                           ] = KX_RETKEY                  ;                  
-			m_reverseKeyTranslateTable[SPACEKEY                         ] = KX_SPACEKEY                ;                  
-			m_reverseKeyTranslateTable[LINEFEEDKEY		        ] = KX_LINEFEEDKEY		;                  
-			m_reverseKeyTranslateTable[BACKSPACEKEY                     ] = KX_BACKSPACEKEY            ;                  
-			m_reverseKeyTranslateTable[DELKEY                           ] = KX_DELKEY                  ;                  
-			m_reverseKeyTranslateTable[SEMICOLONKEY                     ] = KX_SEMICOLONKEY            ;                  
-			m_reverseKeyTranslateTable[PERIODKEY		        ] = KX_PERIODKEY		;                  
-			m_reverseKeyTranslateTable[COMMAKEY		                ] = KX_COMMAKEY		;                  
-			m_reverseKeyTranslateTable[QUOTEKEY		                ] = KX_QUOTEKEY		;                  
-			m_reverseKeyTranslateTable[ACCENTGRAVEKEY	                ] = KX_ACCENTGRAVEKEY	        ;                  
-			m_reverseKeyTranslateTable[MINUSKEY		                ] = KX_MINUSKEY		;                  
-			m_reverseKeyTranslateTable[SLASHKEY		                ] = KX_SLASHKEY		;                  
-			m_reverseKeyTranslateTable[BACKSLASHKEY                     ] = KX_BACKSLASHKEY            ;                  
-			m_reverseKeyTranslateTable[EQUALKEY		                ] = KX_EQUALKEY		;                  
-			m_reverseKeyTranslateTable[LEFTBRACKETKEY	                ] = KX_LEFTBRACKETKEY	        ;                  
-			m_reverseKeyTranslateTable[RIGHTBRACKETKEY	                ] = KX_RIGHTBRACKETKEY	        ;                  
-	                                                                                                           
-			m_reverseKeyTranslateTable[LEFTARROWKEY                     ] = KX_LEFTARROWKEY            ;                  
-			m_reverseKeyTranslateTable[DOWNARROWKEY                     ] = KX_DOWNARROWKEY            ;                  
-			m_reverseKeyTranslateTable[RIGHTARROWKEY	                ] = KX_RIGHTARROWKEY	        ;                  
-			m_reverseKeyTranslateTable[UPARROWKEY		        ] = KX_UPARROWKEY		;                  
-                                                                                                                   
-			m_reverseKeyTranslateTable[PAD2	                        ] = KX_PAD2	                ;                  
-			m_reverseKeyTranslateTable[PAD4	                        ] = KX_PAD4	                ;                  
-			m_reverseKeyTranslateTable[PAD6	                        ] = KX_PAD6	                ;                  
-			m_reverseKeyTranslateTable[PAD8	                        ] = KX_PAD8	                ;                  
-	                                                                                                           
-			m_reverseKeyTranslateTable[PAD1	                        ] = KX_PAD1	                ;                  
-			m_reverseKeyTranslateTable[PAD3	                        ] = KX_PAD3	                ;                  
-			m_reverseKeyTranslateTable[PAD5	                        ] = KX_PAD5	                ;                  
-			m_reverseKeyTranslateTable[PAD7	                        ] = KX_PAD7	                ;                  
-			m_reverseKeyTranslateTable[PAD9	                        ] = KX_PAD9	                ;                  
-
-			m_reverseKeyTranslateTable[PADPERIOD                        ] = KX_PADPERIOD               ;                  
-			m_reverseKeyTranslateTable[PADSLASHKEY                    ] = KX_PADSLASHKEY           ;                  
-			m_reverseKeyTranslateTable[PADASTERKEY                      ] = KX_PADASTERKEY             ;                  
-	                                                                                                           
-	                                                                                                           
-			m_reverseKeyTranslateTable[PAD0	                        ] = KX_PAD0	                ;                  
-			m_reverseKeyTranslateTable[PADMINUS                         ] = KX_PADMINUS                ;                  
-			m_reverseKeyTranslateTable[PADENTER                         ] = KX_PADENTER                ;                  
-			m_reverseKeyTranslateTable[PADPLUSKEY                       ] = KX_PADPLUSKEY              ;                  
-	                                                                                                           
-	                                                                                                           
-			m_reverseKeyTranslateTable[F1KEY                            ] = KX_F1KEY                   ;                  
-			m_reverseKeyTranslateTable[F2KEY                            ] = KX_F2KEY                   ;                  
-			m_reverseKeyTranslateTable[F3KEY                            ] = KX_F3KEY                   ;                  
-			m_reverseKeyTranslateTable[F4KEY                            ] = KX_F4KEY                   ;                  
-			m_reverseKeyTranslateTable[F5KEY                            ] = KX_F5KEY                   ;                  
-			m_reverseKeyTranslateTable[F6KEY                            ] = KX_F6KEY                   ;                  
-			m_reverseKeyTranslateTable[F7KEY                            ] = KX_F7KEY                   ;                  
-			m_reverseKeyTranslateTable[F8KEY                            ] = KX_F8KEY                   ;                  
-			m_reverseKeyTranslateTable[F9KEY                            ] = KX_F9KEY                   ;                  
-			m_reverseKeyTranslateTable[F10KEY                           ] = KX_F10KEY                  ;                  
-			m_reverseKeyTranslateTable[F11KEY      ] = KX_F11KEY                  ;                  
-			m_reverseKeyTranslateTable[F12KEY      ] = KX_F12KEY                  ;
-			m_reverseKeyTranslateTable[F13KEY      ] = KX_F13KEY                  ;
-			m_reverseKeyTranslateTable[F14KEY      ] = KX_F14KEY                  ;
-			m_reverseKeyTranslateTable[F15KEY      ] = KX_F15KEY                  ;
-			m_reverseKeyTranslateTable[F16KEY      ] = KX_F16KEY                  ;
-			m_reverseKeyTranslateTable[F17KEY      ] = KX_F17KEY                  ;
-			m_reverseKeyTranslateTable[F18KEY      ] = KX_F18KEY                  ;
-			m_reverseKeyTranslateTable[F19KEY      ] = KX_F19KEY                  ;
-	                                                                                                           
-			m_reverseKeyTranslateTable[PAUSEKEY    ] = KX_PAUSEKEY                ;                  
-			m_reverseKeyTranslateTable[INSERTKEY   ] = KX_INSERTKEY               ;                  
-			m_reverseKeyTranslateTable[HOMEKEY     ] = KX_HOMEKEY                 ;                  
-			m_reverseKeyTranslateTable[PAGEUPKEY   ] = KX_PAGEUPKEY               ;                  
-			m_reverseKeyTranslateTable[PAGEDOWNKEY ] = KX_PAGEDOWNKEY             ;                  
-			m_reverseKeyTranslateTable[ENDKEY      ] = KX_ENDKEY                  ;                  
-
-		                                                                                                   
-		}                                                                                                          
+		m_reverseKeyTranslateTable[IKEY                             ] = KX_IKEY;
+		m_reverseKeyTranslateTable[JKEY                             ] = KX_JKEY;
+		m_reverseKeyTranslateTable[KKEY                             ] = KX_KKEY;
+		m_reverseKeyTranslateTable[LKEY                             ] = KX_LKEY;
+		m_reverseKeyTranslateTable[MKEY                             ] = KX_MKEY;
+		m_reverseKeyTranslateTable[NKEY                             ] = KX_NKEY;
+		m_reverseKeyTranslateTable[OKEY                             ] = KX_OKEY;
+		m_reverseKeyTranslateTable[PKEY                             ] = KX_PKEY;
+		m_reverseKeyTranslateTable[QKEY                             ] = KX_QKEY;
+		m_reverseKeyTranslateTable[RKEY                             ] = KX_RKEY;
+		m_reverseKeyTranslateTable[SKEY                             ] = KX_SKEY;
+		m_reverseKeyTranslateTable[TKEY                             ] =	KX_TKEY;
+		m_reverseKeyTranslateTable[UKEY                             ] = KX_UKEY;
+		m_reverseKeyTranslateTable[VKEY                             ] = KX_VKEY;
+		m_reverseKeyTranslateTable[WKEY                             ] = KX_WKEY;
+		m_reverseKeyTranslateTable[XKEY                             ] = KX_XKEY;
+		m_reverseKeyTranslateTable[YKEY                             ] = KX_YKEY;
+		m_reverseKeyTranslateTable[ZKEY                             ] = KX_ZKEY;
+
+		m_reverseKeyTranslateTable[ZEROKEY		                ] = KX_ZEROKEY;
+		m_reverseKeyTranslateTable[ONEKEY		                ] = KX_ONEKEY;
+		m_reverseKeyTranslateTable[TWOKEY		                ] = KX_TWOKEY;
+		m_reverseKeyTranslateTable[THREEKEY                     ] = KX_THREEKEY;
+		m_reverseKeyTranslateTable[FOURKEY		                ] = KX_FOURKEY;
+		m_reverseKeyTranslateTable[FIVEKEY		                ] = KX_FIVEKEY;
+		m_reverseKeyTranslateTable[SIXKEY		                ] = KX_SIXKEY;
+		m_reverseKeyTranslateTable[SEVENKEY                         ] = KX_SEVENKEY;
+		m_reverseKeyTranslateTable[EIGHTKEY                         ] = KX_EIGHTKEY;
+		m_reverseKeyTranslateTable[NINEKEY		                ] = KX_NINEKEY;
+
+		m_reverseKeyTranslateTable[CAPSLOCKKEY                      ] = KX_CAPSLOCKKEY;
+
+		m_reverseKeyTranslateTable[LEFTCTRLKEY	                ] = KX_LEFTCTRLKEY;
+		m_reverseKeyTranslateTable[LEFTALTKEY 		        ] = KX_LEFTALTKEY;
+		m_reverseKeyTranslateTable[RIGHTALTKEY 	                ] = KX_RIGHTALTKEY;
+		m_reverseKeyTranslateTable[RIGHTCTRLKEY 	                ] = KX_RIGHTCTRLKEY;
+		m_reverseKeyTranslateTable[RIGHTSHIFTKEY	                ] = KX_RIGHTSHIFTKEY;
+		m_reverseKeyTranslateTable[LEFTSHIFTKEY                     ] = KX_LEFTSHIFTKEY;
+
+		m_reverseKeyTranslateTable[ESCKEY                           ] = KX_ESCKEY;
+		m_reverseKeyTranslateTable[TABKEY                           ] = KX_TABKEY;
+		m_reverseKeyTranslateTable[RETKEY                           ] = KX_RETKEY;
+		m_reverseKeyTranslateTable[SPACEKEY                         ] = KX_SPACEKEY;
+		m_reverseKeyTranslateTable[LINEFEEDKEY		        ] = KX_LINEFEEDKEY;
+		m_reverseKeyTranslateTable[BACKSPACEKEY                     ] = KX_BACKSPACEKEY;
+		m_reverseKeyTranslateTable[DELKEY                           ] = KX_DELKEY;
+		m_reverseKeyTranslateTable[SEMICOLONKEY                     ] = KX_SEMICOLONKEY;
+		m_reverseKeyTranslateTable[PERIODKEY		        ] = KX_PERIODKEY;
+		m_reverseKeyTranslateTable[COMMAKEY		                ] = KX_COMMAKEY;
+		m_reverseKeyTranslateTable[QUOTEKEY		                ] = KX_QUOTEKEY;
+		m_reverseKeyTranslateTable[ACCENTGRAVEKEY	                ] = KX_ACCENTGRAVEKEY;
+		m_reverseKeyTranslateTable[MINUSKEY		                ] = KX_MINUSKEY;
+		m_reverseKeyTranslateTable[SLASHKEY		                ] = KX_SLASHKEY;
+		m_reverseKeyTranslateTable[BACKSLASHKEY                     ] = KX_BACKSLASHKEY;
+		m_reverseKeyTranslateTable[EQUALKEY		                ] = KX_EQUALKEY;
+		m_reverseKeyTranslateTable[LEFTBRACKETKEY	                ] = KX_LEFTBRACKETKEY;
+		m_reverseKeyTranslateTable[RIGHTBRACKETKEY	                ] = KX_RIGHTBRACKETKEY;
+
+		m_reverseKeyTranslateTable[LEFTARROWKEY                     ] = KX_LEFTARROWKEY;
+		m_reverseKeyTranslateTable[DOWNARROWKEY                     ] = KX_DOWNARROWKEY;
+		m_reverseKeyTranslateTable[RIGHTARROWKEY	                ] = KX_RIGHTARROWKEY;
+		m_reverseKeyTranslateTable[UPARROWKEY		        ] = KX_UPARROWKEY;
+
+		m_reverseKeyTranslateTable[PAD2	                        ] = KX_PAD2;
+		m_reverseKeyTranslateTable[PAD4	                        ] = KX_PAD4;
+		m_reverseKeyTranslateTable[PAD6	                        ] = KX_PAD6;
+		m_reverseKeyTranslateTable[PAD8	                        ] = KX_PAD8;
+
+		m_reverseKeyTranslateTable[PAD1	                        ] = KX_PAD1;
+		m_reverseKeyTranslateTable[PAD3	                        ] = KX_PAD3;
+		m_reverseKeyTranslateTable[PAD5	                        ] = KX_PAD5;
+		m_reverseKeyTranslateTable[PAD7	                        ] = KX_PAD7;
+		m_reverseKeyTranslateTable[PAD9	                        ] = KX_PAD9;
+
+		m_reverseKeyTranslateTable[PADPERIOD                        ] = KX_PADPERIOD;
+		m_reverseKeyTranslateTable[PADSLASHKEY                    ] = KX_PADSLASHKEY;
+		m_reverseKeyTranslateTable[PADASTERKEY                      ] = KX_PADASTERKEY;
+
+
+		m_reverseKeyTranslateTable[PAD0	                        ] = KX_PAD0;
+		m_reverseKeyTranslateTable[PADMINUS                         ] = KX_PADMINUS;
+		m_reverseKeyTranslateTable[PADENTER                         ] = KX_PADENTER;
+		m_reverseKeyTranslateTable[PADPLUSKEY                       ] = KX_PADPLUSKEY;
+
+
+		m_reverseKeyTranslateTable[F1KEY                            ] = KX_F1KEY;
+		m_reverseKeyTranslateTable[F2KEY                            ] = KX_F2KEY;
+		m_reverseKeyTranslateTable[F3KEY                            ] = KX_F3KEY;
+		m_reverseKeyTranslateTable[F4KEY                            ] = KX_F4KEY;
+		m_reverseKeyTranslateTable[F5KEY                            ] = KX_F5KEY;
+		m_reverseKeyTranslateTable[F6KEY                            ] = KX_F6KEY;
+		m_reverseKeyTranslateTable[F7KEY                            ] = KX_F7KEY;
+		m_reverseKeyTranslateTable[F8KEY                            ] = KX_F8KEY;
+		m_reverseKeyTranslateTable[F9KEY                            ] = KX_F9KEY;
+		m_reverseKeyTranslateTable[F10KEY                           ] = KX_F10KEY;
+		m_reverseKeyTranslateTable[F11KEY      ] = KX_F11KEY;
+		m_reverseKeyTranslateTable[F12KEY      ] = KX_F12KEY;
+		m_reverseKeyTranslateTable[F13KEY      ] = KX_F13KEY;
+		m_reverseKeyTranslateTable[F14KEY      ] = KX_F14KEY;
+		m_reverseKeyTranslateTable[F15KEY      ] = KX_F15KEY;
+		m_reverseKeyTranslateTable[F16KEY      ] = KX_F16KEY;
+		m_reverseKeyTranslateTable[F17KEY      ] = KX_F17KEY;
+		m_reverseKeyTranslateTable[F18KEY      ] = KX_F18KEY;
+		m_reverseKeyTranslateTable[F19KEY      ] = KX_F19KEY;
+
+		m_reverseKeyTranslateTable[PAUSEKEY    ] = KX_PAUSEKEY;
+		m_reverseKeyTranslateTable[INSERTKEY   ] = KX_INSERTKEY;
+		m_reverseKeyTranslateTable[HOMEKEY     ] = KX_HOMEKEY;
+		m_reverseKeyTranslateTable[PAGEUPKEY   ] = KX_PAGEUPKEY;
+		m_reverseKeyTranslateTable[PAGEDOWNKEY ] = KX_PAGEDOWNKEY;
+		m_reverseKeyTranslateTable[ENDKEY      ] = KX_ENDKEY;
+	}
 
 	virtual ~BL_BlenderInputDevice()
-		{
+	{
 
-		}
-                                                                                                                   
-	 KX_EnumInputs ToNative(unsigned short incode) {
+	}
+
+	KX_EnumInputs ToNative(unsigned short incode) {
 		return m_reverseKeyTranslateTable[incode];
 	}
 
 	virtual bool	IsPressed(SCA_IInputDevice::KX_EnumInputs inputcode)=0;
-//	virtual const SCA_InputEvent&	GetEventValue(SCA_IInputDevice::KX_EnumInputs inputcode)=0;
+	//	virtual const SCA_InputEvent&	GetEventValue(SCA_IInputDevice::KX_EnumInputs inputcode)=0;
 	virtual bool	ConvertBlenderEvent(unsigned short incode,short val)=0;
 
-	
+
 #ifdef WITH_CXX_GUARDEDALLOC
 public:
 	void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_BlenderInputDevice"); }
 	void operator delete(void *mem) { MEM_freeN(mem); }
 #endif
-};                                                                                                                 
+};
 #endif //__KX_BLENDERINPUTDEVICE
 
diff --git a/source/gameengine/Converter/BL_ActionActuator.cpp b/source/gameengine/Converter/BL_ActionActuator.cpp
index c00e7ec7e29..895def17e8e 100644
--- a/source/gameengine/Converter/BL_ActionActuator.cpp
+++ b/source/gameengine/Converter/BL_ActionActuator.cpp
@@ -36,6 +36,7 @@
 #include "BL_ActionActuator.h"
 #include "BL_ArmatureObject.h"
 #include "BL_SkinDeformer.h"
+#include "BL_Action.h"
 #include "KX_GameObject.h"
 #include "STR_HashedString.h"
 #include "MEM_guardedalloc.h"
@@ -60,6 +61,49 @@ extern "C" {
 #include "RNA_define.h"
 }
 
+BL_ActionActuator::BL_ActionActuator(SCA_IObject* gameobj,
+					const STR_String& propname,
+					const STR_String& framepropname,
+					float starttime,
+					float endtime,
+					struct bAction *action,
+					short	playtype,
+					short	blendin,
+					short	priority,
+					short	layer,
+					float	layer_weight,
+					short	ipo_flags,
+					short	end_reset,
+					float	stride) 
+	: SCA_IActuator(gameobj, KX_ACT_ACTION),
+		
+	m_lastpos(0, 0, 0),
+	m_blendframe(0),
+	m_flag(0),
+	m_startframe (starttime),
+	m_endframe(endtime) ,
+	m_starttime(0),
+	m_localtime(starttime),
+	m_lastUpdate(-1),
+	m_blendin(blendin),
+	m_blendstart(0),
+	m_stridelength(stride),
+	m_layer_weight(layer_weight),
+	m_playtype(playtype),
+	m_priority(priority),
+	m_layer(layer),
+	m_ipo_flags(ipo_flags),
+	m_pose(NULL),
+	m_blendpose(NULL),
+	m_userpose(NULL),
+	m_action(action),
+	m_propname(propname),
+	m_framepropname(framepropname)		
+{
+	if (!end_reset)
+		m_flag |= ACT_FLAG_CONTINUE;
+};
+
 BL_ActionActuator::~BL_ActionActuator()
 {
 	if (m_pose)
@@ -85,370 +129,220 @@ void BL_ActionActuator::SetBlendTime (float newtime){
 	m_blendframe = newtime;
 }
 
-CValue* BL_ActionActuator::GetReplica() {
-	BL_ActionActuator* replica = new BL_ActionActuator(*this);//m_float,GetName());
-	replica->ProcessReplica();
-	return replica;
-}
-
-bool BL_ActionActuator::ClampLocalTime()
+void BL_ActionActuator::SetLocalTime(float curtime)
 {
-	if (m_startframe < m_endframe)
+	float dt = (curtime-m_starttime)*KX_KetsjiEngine::GetAnimFrameRate();
+
+	if (m_endframe < m_startframe)
+		dt = -dt;
+
+	m_localtime = m_startframe + dt;
+	
+	// Handle wrap around
+	if (m_localtime < min(m_startframe, m_endframe) || m_localtime > max(m_startframe, m_endframe))
 	{
-		if (m_localtime < m_startframe)
-		{
-			m_localtime = m_startframe;
-			return true;
-		} 
-		else if (m_localtime > m_endframe)
+		switch(m_playtype)
 		{
+		case ACT_ACTION_PLAY:
+			// Clamp
 			m_localtime = m_endframe;
-			return true;
-		}
-	} else {
-		if (m_localtime > m_startframe)
-		{
+			break;
+		case ACT_ACTION_LOOP_END:
+			// Put the time back to the beginning
 			m_localtime = m_startframe;
-			return true;
-		}
-		else if (m_localtime < m_endframe)
-		{
-			m_localtime = m_endframe;
-			return true;
+			m_starttime = curtime;
+			break;
+		case ACT_ACTION_PINGPONG:
+			// Swap the start and end frames
+			float temp = m_startframe;
+			m_startframe = m_endframe;
+			m_endframe = temp;
+
+			m_starttime = curtime;
+
+			break;
 		}
 	}
-	return false;
 }
 
-void BL_ActionActuator::SetStartTime(float curtime)
+void BL_ActionActuator::ResetStartTime(float curtime)
 {
-	float direction = m_startframe < m_endframe ? 1.0 : -1.0;
-	
-	if (!(m_flag & ACT_FLAG_REVERSE))
-		m_starttime = curtime - direction*(m_localtime - m_startframe)/KX_KetsjiEngine::GetAnimFrameRate();
-	else
-		m_starttime = curtime - direction*(m_endframe - m_localtime)/KX_KetsjiEngine::GetAnimFrameRate();
-}
+	float dt = m_localtime - m_startframe;
 
-void BL_ActionActuator::SetLocalTime(float curtime)
-{
-	float delta_time = (curtime - m_starttime)*KX_KetsjiEngine::GetAnimFrameRate();
-	
-	if (m_endframe < m_startframe)
-		delta_time = -delta_time;
-
-	if (!(m_flag & ACT_FLAG_REVERSE))
-		m_localtime = m_startframe + delta_time;
-	else
-		m_localtime = m_endframe - delta_time;
+	m_starttime = curtime - dt / (KX_KetsjiEngine::GetAnimFrameRate());
+	//SetLocalTime(curtime);
 }
 
+CValue* BL_ActionActuator::GetReplica() {
+	BL_ActionActuator* replica = new BL_ActionActuator(*this);//m_float,GetName());
+	replica->ProcessReplica();
+	return replica;
+}
 
 bool BL_ActionActuator::Update(double curtime, bool frame)
 {
 	bool bNegativeEvent = false;
 	bool bPositiveEvent = false;
-	bool keepgoing = true;
-	bool wrap = false;
-	bool apply=true;
-	int	priority;
-	float newweight;
+	bool bUseContinue = false;
+	KX_GameObject *obj = (KX_GameObject*)GetParent();
+	short playtype = BL_Action::ACT_MODE_PLAY;
+	float start = m_startframe;
+	float end = m_endframe;
+
+	// If we don't have an action, we can't do anything
+	if (!m_action)
+		return false;
+
+	// Convert our playtype to one that BL_Action likes
+	switch(m_playtype)
+	{
+		case ACT_ACTION_LOOP_END:
+		case ACT_ACTION_LOOP_STOP:
+			playtype = BL_Action::ACT_MODE_LOOP;
+			break;
+
+		case ACT_ACTION_PINGPONG:
+			// We handle ping pong ourselves to increase compabitility
+			// with files made prior to animation changes from GSoC 2011.
+			playtype = BL_Action::ACT_MODE_PLAY;
+		
+			if (m_flag & ACT_FLAG_REVERSE)
+			{
+				m_localtime = start;
+				start = end;
+				end = m_localtime;
+			}
+
+			break;
+		case ACT_ACTION_FROM_PROP:
+			CValue* prop = GetParent()->GetProperty(m_propname);
+
+			// If we don't have a property, we can't do anything, so just bail
+			if (!prop) return false;
 
-	curtime -= KX_KetsjiEngine::GetSuspendedDelta();
+			playtype = BL_Action::ACT_MODE_PLAY;
+			start = end = prop->GetNumber();
+
+			break;
+	}
+
+	// Continue only really makes sense for play stop and flipper. All other modes go until they are complete.
+	if (m_flag & ACT_FLAG_CONTINUE &&
+		(m_playtype == ACT_ACTION_LOOP_STOP ||
+		m_playtype == ACT_ACTION_FLIPPER))
+		bUseContinue = true;
 	
-	// result = true if animation has to be continued, false if animation stops
-	// maybe there are events for us in the queue !
+	
+	// Handle events
 	if (frame)
 	{
 		bNegativeEvent = m_negevent;
 		bPositiveEvent = m_posevent;
 		RemoveAllEvents();
-		
-		if (bPositiveEvent)
-			m_flag |= ACT_FLAG_ACTIVE;
-		
-		if (bNegativeEvent)
-		{
-			// dont continue where we left off when restarting
-			if (m_end_reset) {
-				m_flag &= ~ACT_FLAG_LOCKINPUT;
-			}
-			
-			if (!(m_flag & ACT_FLAG_ACTIVE))
-				return false;
-			m_flag &= ~ACT_FLAG_ACTIVE;
-		}
 	}
-	
-	/*	We know that action actuators have been discarded from all non armature objects:
-	if we're being called, we're attached to a BL_ArmatureObject */
-	BL_ArmatureObject *obj = (BL_ArmatureObject*)GetParent();
-	float length = m_endframe - m_startframe;
-	
-	priority = m_priority;
-	
-	/* Determine pre-incrementation behaviour and set appropriate flags */
-	switch (m_playtype){
-	case ACT_ACTION_MOTION:
-		if (bNegativeEvent){
-			keepgoing=false;
-			apply=false;
-		};
-		break;
-	case ACT_ACTION_FROM_PROP:
-		if (bNegativeEvent){
-			apply=false;
-			keepgoing=false;
-		}
-		break;
-	case ACT_ACTION_LOOP_END:
-		if (bPositiveEvent){
-			if (!(m_flag & ACT_FLAG_LOCKINPUT)){
-				m_flag &= ~ACT_FLAG_KEYUP;
-				m_flag &= ~ACT_FLAG_REVERSE;
-				m_flag |= ACT_FLAG_LOCKINPUT;
-				m_localtime = m_startframe;
-				m_starttime = curtime;
-			}
-		}
-		if (bNegativeEvent){
-			m_flag |= ACT_FLAG_KEYUP;
-		}
-		break;
-	case ACT_ACTION_LOOP_STOP:
-		if (bPositiveEvent){
-			if (!(m_flag & ACT_FLAG_LOCKINPUT)){
-				m_flag &= ~ACT_FLAG_REVERSE;
-				m_flag &= ~ACT_FLAG_KEYUP;
-				m_flag |= ACT_FLAG_LOCKINPUT;
-				SetStartTime(curtime);
-			}
-		}
-		if (bNegativeEvent){
-			m_flag |= ACT_FLAG_KEYUP;
-			m_flag &= ~ACT_FLAG_LOCKINPUT;
-			keepgoing=false;
-			apply=false;
-		}
-		break;
-	case ACT_ACTION_PINGPONG:
-		if (bPositiveEvent){
-			if (!(m_flag & ACT_FLAG_LOCKINPUT)){
-				m_flag &= ~ACT_FLAG_KEYUP;
-				m_localtime = m_starttime;
-				m_starttime = curtime;
-				m_flag |= ACT_FLAG_LOCKINPUT;
-			}
-		}
-		break;
-	case ACT_ACTION_FLIPPER:
-		if (bPositiveEvent){
-			if (!(m_flag & ACT_FLAG_LOCKINPUT)){
-				m_flag &= ~ACT_FLAG_REVERSE;
-				m_flag |= ACT_FLAG_LOCKINPUT;
-				SetStartTime(curtime);
-			}
-		}
-		else if (bNegativeEvent){
-			m_flag |= ACT_FLAG_REVERSE;
-			m_flag &= ~ACT_FLAG_LOCKINPUT;
-			SetStartTime(curtime);
-		}
-		break;
-	case ACT_ACTION_PLAY:
-		if (bPositiveEvent){
-			if (!(m_flag & ACT_FLAG_LOCKINPUT)){
-				m_flag &= ~ACT_FLAG_REVERSE;
-				m_localtime = m_starttime;
-				m_starttime = curtime;
-				m_flag |= ACT_FLAG_LOCKINPUT;
-			}
-		}
-		break;
-	default:
-		break;
+
+	if (m_flag & ACT_FLAG_ATTEMPT_PLAY)
+		SetLocalTime(curtime);
+
+	if (bUseContinue && (m_flag & ACT_FLAG_ACTIVE))
+	{
+		m_localtime = obj->GetActionFrame(m_layer);
+		ResetStartTime(curtime);
 	}
-	
-	/* Perform increment */
-	if (keepgoing){
-		if (m_playtype == ACT_ACTION_MOTION){
-			MT_Point3	newpos;
-			MT_Point3	deltapos;
-			
-			newpos = obj->NodeGetWorldPosition();
-			
-			/* Find displacement */
-			deltapos = newpos-m_lastpos;
-			m_localtime += (length/m_stridelength) * deltapos.length();
-			m_lastpos = newpos;
-		}
-		else{
-			SetLocalTime(curtime);
-		}
+
+	// Handle a frame property if it's defined
+	if ((m_flag & ACT_FLAG_ACTIVE) && m_framepropname[0] != 0)
+	{
+		CValue* oldprop = obj->GetProperty(m_framepropname);
+		CValue* newval = new CFloatValue(obj->GetActionFrame(m_layer));
+		if (oldprop)
+			oldprop->SetValue(newval);
+		else
+			obj->SetProperty(m_framepropname, newval);
+
+		newval->Release();
 	}
-	
-	/* Check if a wrapping response is needed */
-	if (length){
-		if (m_localtime < m_startframe || m_localtime > m_endframe)
-		{
-			m_localtime = m_startframe + fmod(m_localtime, length);
-			wrap = true;
-		}
+
+	// Handle a finished animation
+	if ((m_flag & ACT_FLAG_PLAY_END) && obj->IsActionDone(m_layer))
+	{
+		m_flag &= ~ACT_FLAG_ACTIVE;
+		m_flag &= ~ACT_FLAG_ATTEMPT_PLAY;
+		obj->StopAction(m_layer);
+		return false;
 	}
-	else
-		m_localtime = m_startframe;
 	
-	/* Perform post-increment tasks */
-	switch (m_playtype){
-	case ACT_ACTION_FROM_PROP:
+	// If a different action is playing, we've been overruled and are no longer active
+	if (obj->GetCurrentAction(m_layer) != m_action)
+		m_flag &= ~ACT_FLAG_ACTIVE;
+
+	if (bPositiveEvent || (m_flag & ACT_FLAG_ATTEMPT_PLAY && !(m_flag & ACT_FLAG_ACTIVE)))
+	{
+		if (bPositiveEvent)
+			ResetStartTime(curtime);
+
+		if (obj->PlayAction(m_action->id.name+2, start, end, m_layer, m_priority, m_blendin, playtype, m_layer_weight, m_ipo_flags))
 		{
-			CValue* propval = GetParent()->GetProperty(m_propname);
-			if (propval)
-				m_localtime = propval->GetNumber();
-			
-			if (bNegativeEvent){
-				keepgoing=false;
-			}
-		}
-		break;
-	case ACT_ACTION_MOTION:
-		break;
-	case ACT_ACTION_LOOP_STOP:
-		break;
-	case ACT_ACTION_PINGPONG:
-		if (wrap){
-			if (!(m_flag & ACT_FLAG_REVERSE))
-				m_localtime = m_endframe;
-			else 
-				m_localtime = m_startframe;
-
-			m_flag &= ~ACT_FLAG_LOCKINPUT;
-			m_flag ^= ACT_FLAG_REVERSE; //flip direction
-			keepgoing = false;
-		}
-		break;
-	case ACT_ACTION_FLIPPER:
-		if (wrap){
-			if (!(m_flag & ACT_FLAG_REVERSE)){
-				m_localtime=m_endframe;
-				//keepgoing = false;
-			}
-			else {
-				m_localtime=m_startframe;
-				keepgoing = false;
-			}
-		}
-		break;
-	case ACT_ACTION_LOOP_END:
-		if (wrap){
-			if (m_flag & ACT_FLAG_KEYUP){
-				keepgoing = false;
-				m_localtime = m_endframe;
-				m_flag &= ~ACT_FLAG_LOCKINPUT;
-			}
-			SetStartTime(curtime);
-		}
-		break;
-	case ACT_ACTION_PLAY:
-		if (wrap){
-			m_localtime = m_endframe;
-			keepgoing = false;
-			m_flag &= ~ACT_FLAG_LOCKINPUT;
+			m_flag |= ACT_FLAG_ACTIVE;
+			if (bUseContinue)
+				obj->SetActionFrame(m_layer, m_localtime);
+
+			if (m_playtype == ACT_ACTION_PLAY)
+				m_flag |= ACT_FLAG_PLAY_END;
+			else
+				m_flag &= ~ACT_FLAG_PLAY_END;
 		}
-		break;
-	default:
-		keepgoing = false;
-		break;
+		m_flag |= ACT_FLAG_ATTEMPT_PLAY;
 	}
-	
-	/* Set the property if its defined */
-	if (m_framepropname[0] != '\0') {
-		CValue* propowner = GetParent();
-		CValue* oldprop = propowner->GetProperty(m_framepropname);
-		CValue* newval = new CFloatValue(m_localtime);
-		if (oldprop) {
-			oldprop->SetValue(newval);
-		} else {
-			propowner->SetProperty(m_framepropname, newval);
+	else if ((m_flag & ACT_FLAG_ACTIVE) && bNegativeEvent)
+	{	
+		m_flag &= ~ACT_FLAG_ATTEMPT_PLAY;
+		bAction *curr_action = obj->GetCurrentAction(m_layer);
+		if (curr_action && curr_action != m_action)
+		{
+			// Someone changed the action on us, so we wont mess with it
+			// Hopefully there wont be too many problems with two actuators using
+			// the same action...
+			m_flag &= ~ACT_FLAG_ACTIVE;
+			return false;
 		}
-		newval->Release();
-	}
-	
-	if (bNegativeEvent)
-		m_blendframe=0.0;
-	
-	/* Apply the pose if necessary*/
-	if (apply){
-
-		/* Priority test */
-		if (obj->SetActiveAction(this, priority, curtime)){
-			
-			/* Get the underlying pose from the armature */
-			obj->GetPose(&m_pose);
-
-// 2.4x function, 
-			/* Override the necessary channels with ones from the action */
-			// XXX extract_pose_from_action(m_pose, m_action, m_localtime);
-			
-			
-// 2.5x - replacement for extract_pose_from_action(...) above.
-			{
-				struct PointerRNA id_ptr;
-				Object *arm= obj->GetArmatureObject();
-				bPose *pose_back= arm->pose;
-				
-				arm->pose= m_pose;
-				RNA_id_pointer_create((ID *)arm, &id_ptr);
-				animsys_evaluate_action(&id_ptr, m_action, NULL, m_localtime);
-				
-				arm->pose= pose_back;
-			
-// 2.5x - could also do this but looks too high level, constraints use this, it works ok.
-//				Object workob; /* evaluate using workob */
-//				what_does_obaction((Scene *)obj->GetScene(), obj->GetArmatureObject(), &workob, m_pose, m_action, NULL, m_localtime);
-			}
 
-			// done getting the pose from the action
-			
-			/* Perform the user override (if any) */
-			if (m_userpose){
-				extract_pose_from_pose(m_pose, m_userpose);
-				game_free_pose(m_userpose); //cant use MEM_freeN(m_userpose) because the channels need freeing too.
-				m_userpose = NULL;
-			}
-#if 1
-			/* Handle blending */
-			if (m_blendin && (m_blendframe<m_blendin)){
-				/* If this is the start of a blending sequence... */
-				if ((m_blendframe==0.0) || (!m_blendpose)){
-					obj->GetMRDPose(&m_blendpose);
-					m_blendstart = curtime;
-				}
-				
-				/* Find percentages */
-				newweight = (m_blendframe/(float)m_blendin);
-				game_blend_poses(m_pose, m_blendpose, 1.0 - newweight);
-
-				/* Increment current blending percentage */
-				m_blendframe = (curtime - m_blendstart)*KX_KetsjiEngine::GetAnimFrameRate();
-				if (m_blendframe>m_blendin)
-					m_blendframe = m_blendin;
-				
-			}
-#endif
-			m_lastUpdate = m_localtime;
-			obj->SetPose (m_pose);
-		}
-		else{
-			m_blendframe = 0.0;
+		
+		m_localtime = obj->GetActionFrame(m_layer);
+		if (m_localtime < min(m_startframe, m_endframe) || m_localtime > max(m_startframe, m_endframe))
+			m_localtime = m_startframe;
+
+		switch(m_playtype)
+		{
+			case ACT_ACTION_LOOP_STOP:
+				obj->StopAction(m_layer); // Stop the action after getting the frame
+
+				// We're done
+				m_flag &= ~ACT_FLAG_ACTIVE;
+				return false;
+			case ACT_ACTION_PINGPONG:
+				m_flag ^= ACT_FLAG_REVERSE;
+				// Now fallthrough to LOOP_END code
+			case ACT_ACTION_LOOP_END:
+				// Convert into a play and let it finish
+				obj->SetPlayMode(m_layer, BL_Action::ACT_MODE_PLAY);
+
+				m_flag |= ACT_FLAG_PLAY_END;
+				break;
+	
+			case ACT_ACTION_FLIPPER:
+				// Convert into a play action and play back to the beginning
+				end = start;
+				start = obj->GetActionFrame(m_layer);
+				obj->PlayAction(m_action->id.name+2, start, end, m_layer, m_priority, 0, BL_Action::ACT_MODE_PLAY, m_layer_weight, m_ipo_flags);
+
+				m_flag |= ACT_FLAG_PLAY_END;
+				break;
 		}
 	}
-	
-	if (!keepgoing){
-		m_blendframe = 0.0;
-	}
-	return keepgoing;
-};
+
+	return true;
+}
 
 #ifdef WITH_PYTHON
 
@@ -633,10 +527,10 @@ PyAttributeDef BL_ActionActuator::Attributes[] = {
 	KX_PYATTRIBUTE_RW_FUNCTION("action", BL_ActionActuator, pyattr_get_action, pyattr_set_action),
 	KX_PYATTRIBUTE_RO_FUNCTION("channelNames", BL_ActionActuator, pyattr_get_channel_names),
 	KX_PYATTRIBUTE_SHORT_RW("priority", 0, 100, false, BL_ActionActuator, m_priority),
-	KX_PYATTRIBUTE_FLOAT_RW_CHECK("frame", 0, MAXFRAMEF, BL_ActionActuator, m_localtime, CheckFrame),
+	KX_PYATTRIBUTE_RW_FUNCTION("frame", BL_ActionActuator, pyattr_get_frame, pyattr_set_frame),
 	KX_PYATTRIBUTE_STRING_RW("propName", 0, 31, false, BL_ActionActuator, m_propname),
 	KX_PYATTRIBUTE_STRING_RW("framePropName", 0, 31, false, BL_ActionActuator, m_framepropname),
-	KX_PYATTRIBUTE_BOOL_RW("useContinue", BL_ActionActuator, m_end_reset),
+	KX_PYATTRIBUTE_RW_FUNCTION("useContinue", BL_ActionActuator, pyattr_get_use_continue, pyattr_set_use_continue),
 	KX_PYATTRIBUTE_FLOAT_RW_CHECK("blendTime", 0, MAXFRAMEF, BL_ActionActuator, m_blendframe, CheckBlendTime),
 	KX_PYATTRIBUTE_SHORT_RW_CHECK("mode",0,100,false,BL_ActionActuator,m_playtype,CheckType),
 	{ NULL }	//Sentinel
@@ -696,4 +590,37 @@ PyObject* BL_ActionActuator::pyattr_get_channel_names(void *self_v, const KX_PYA
 	return ret;
 }
 
+PyObject* BL_ActionActuator::pyattr_get_use_continue(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
+	return PyBool_FromLong(self->m_flag & ACT_FLAG_CONTINUE);
+}
+
+int BL_ActionActuator::pyattr_set_use_continue(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
+	
+	if (PyObject_IsTrue(value))
+		self->m_flag |= ACT_FLAG_CONTINUE;
+	else
+		self->m_flag &= ~ACT_FLAG_CONTINUE;
+	
+	return PY_SET_ATTR_SUCCESS;
+}
+
+PyObject* BL_ActionActuator::pyattr_get_frame(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
+	return PyFloat_FromDouble(((KX_GameObject*)self->m_gameobj)->GetActionFrame(self->m_layer));
+}
+
+int BL_ActionActuator::pyattr_set_frame(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ActionActuator* self= static_cast<BL_ActionActuator*>(self_v);
+	
+	((KX_GameObject*)self->m_gameobj)->SetActionFrame(self->m_layer, PyFloat_AsDouble(value));
+	
+	return PY_SET_ATTR_SUCCESS;
+}
+
 #endif // WITH_PYTHON
diff --git a/source/gameengine/Converter/BL_ActionActuator.h b/source/gameengine/Converter/BL_ActionActuator.h
index ff4ca785a96..357c2b4a05e 100644
--- a/source/gameengine/Converter/BL_ActionActuator.h
+++ b/source/gameengine/Converter/BL_ActionActuator.h
@@ -52,38 +52,20 @@ public:
 						short	playtype,
 						short	blendin,
 						short	priority,
+						short	layer,
+						float	layer_weight,
+						short	ipo_flags,
 						short	end_reset,
-						float	stride) 
-		: SCA_IActuator(gameobj, KX_ACT_ACTION),
-		
-		m_lastpos(0, 0, 0),
-		m_blendframe(0),
-		m_flag(0),
-		m_startframe (starttime),
-		m_endframe(endtime) ,
-		m_starttime(0),
-		m_localtime(starttime),
-		m_lastUpdate(-1),
-		m_blendin(blendin),
-		m_blendstart(0),
-		m_stridelength(stride),
-		m_playtype(playtype),
-		m_priority(priority),
-		m_end_reset(end_reset),
-		m_pose(NULL),
-		m_blendpose(NULL),
-		m_userpose(NULL),
-		m_action(action),
-		m_propname(propname),
-		m_framepropname(framepropname)		
-	{
-	};
+						float	stride);
+
 	virtual ~BL_ActionActuator();
 	virtual	bool Update(double curtime, bool frame);
 	virtual CValue* GetReplica();
 	virtual void ProcessReplica();
 	
 	void SetBlendTime (float newtime);
+	void SetLocalTime (float curtime);
+	void ResetStartTime (float curtime);
 	
 	bAction*	GetAction() { return m_action; }
 	void		SetAction(bAction* act) { m_action= act; }
@@ -96,18 +78,10 @@ public:
 	static PyObject*	pyattr_get_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
 	static int			pyattr_set_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 	static PyObject*	pyattr_get_channel_names(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
-	/* attribute check */
-	static int CheckFrame(void *self, const PyAttributeDef*)
-	{
-		BL_ActionActuator* act = reinterpret_cast<BL_ActionActuator*>(self);
-
-		if (act->m_localtime < act->m_startframe)
-			act->m_localtime = act->m_startframe;
-		else if (act->m_localtime > act->m_endframe)
-			act->m_localtime = act->m_endframe;
-
-		return 0;
-	}
+	static PyObject*	pyattr_get_use_continue(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static int			pyattr_set_use_continue(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	static PyObject*	pyattr_get_frame(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static int			pyattr_set_frame(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 
 	static int CheckBlendTime(void *self, const PyAttributeDef*)
 	{
@@ -139,11 +113,6 @@ public:
 #endif // WITH_PYTHON
 	
 protected:
-
-	void SetStartTime(float curtime);
-	void SetLocalTime(float curtime);
-	bool ClampLocalTime();
-
 	MT_Point3	m_lastpos;
 	float	m_blendframe;
 	int		m_flag;
@@ -160,9 +129,11 @@ protected:
 	float	m_blendin;
 	float	m_blendstart;
 	float	m_stridelength;
+	float	m_layer_weight;
 	short	m_playtype;
 	short	m_priority;
-	bool	m_end_reset;
+	short	m_layer;
+	short	m_ipo_flags;
 	struct bPose* m_pose;
 	struct bPose* m_blendpose;
 	struct bPose* m_userpose;
@@ -171,11 +142,17 @@ protected:
 	STR_String	m_framepropname;
 };
 
+// Not all of these values are used in BL_ActionActuator anymore,
+// but BL_ShapeActionActuator still uses them, so we keep them around
+// for now.
 enum {
-	ACT_FLAG_REVERSE	= 0x00000001,
-	ACT_FLAG_LOCKINPUT	= 0x00000002,
-	ACT_FLAG_KEYUP		= 0x00000004,
-	ACT_FLAG_ACTIVE		= 0x00000008
+	ACT_FLAG_REVERSE	= 1<<0,
+	ACT_FLAG_LOCKINPUT	= 1<<1,
+	ACT_FLAG_KEYUP		= 1<<2,
+	ACT_FLAG_ACTIVE		= 1<<3,
+	ACT_FLAG_CONTINUE	= 1<<4,
+	ACT_FLAG_PLAY_END	= 1<<5,
+	ACT_FLAG_ATTEMPT_PLAY = 1<<6,
 };
 
 #endif
diff --git a/source/gameengine/Converter/BL_ArmatureObject.cpp b/source/gameengine/Converter/BL_ArmatureObject.cpp
index c6c20a96482..684bd3f341e 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.cpp
+++ b/source/gameengine/Converter/BL_ArmatureObject.cpp
@@ -218,7 +218,8 @@ BL_ArmatureObject::BL_ArmatureObject(
 				void* sgReplicationInfo, 
 				SG_Callbacks callbacks, 
 				Object *armature,
-				Scene *scene)
+				Scene *scene,
+				int vert_deform_type)
 
 :	KX_GameObject(sgReplicationInfo,callbacks),
 	m_controlledConstraints(),
@@ -230,6 +231,7 @@ BL_ArmatureObject::BL_ArmatureObject(
 	m_timestep(0.040),
 	m_activeAct(NULL),
 	m_activePriority(999),
+	m_vert_deform_type(vert_deform_type),
 	m_constraintNumber(0),
 	m_channelNumber(0),
 	m_lastapplyframe(0.0)
@@ -298,6 +300,7 @@ void BL_ArmatureObject::LoadConstraints(KX_BlenderSceneConverter* converter)
 			case CONSTRAINT_TYPE_CLAMPTO:
 			case CONSTRAINT_TYPE_TRANSFORM:
 			case CONSTRAINT_TYPE_DISTLIMIT:
+			case CONSTRAINT_TYPE_TRANSLIKE:
 				cti = constraint_get_typeinfo(pcon);
 				gametarget = gamesubtarget = NULL;
 				if (cti && cti->get_constraint_targets) {
diff --git a/source/gameengine/Converter/BL_ArmatureObject.h b/source/gameengine/Converter/BL_ArmatureObject.h
index 2c3ca7404b3..1467f05c1bd 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.h
+++ b/source/gameengine/Converter/BL_ArmatureObject.h
@@ -69,7 +69,8 @@ public:
 		void* sgReplicationInfo,
 		SG_Callbacks callbacks,
 		Object *armature,
-		Scene *scene
+		Scene *scene,
+		int vert_deform_type
 	);
 	virtual ~BL_ArmatureObject();
 
@@ -90,6 +91,8 @@ public:
 	
 	Object* GetArmatureObject() {return m_objArma;}
 
+	int GetVertDeformType() {return m_vert_deform_type;}
+
 	// for constraint python API
 	void LoadConstraints(KX_BlenderSceneConverter* converter);
 	size_t GetConstraintNumber() const { return m_constraintNumber; }
@@ -136,6 +139,7 @@ protected:
 	double  m_timestep;		// delta since last pose evaluation.
 	class BL_ActionActuator *m_activeAct;
 	short	m_activePriority;
+	int		m_vert_deform_type;
 	size_t  m_constraintNumber;
 	size_t  m_channelNumber;
 	// store the original armature object matrix
diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index 4b475a4b5e7..d4b43cd7ac1 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -353,6 +353,8 @@ bool ConvertMaterial(
 
 		// use lighting?
 		material->ras_mode |= ( mat->mode & MA_SHLESS )?0:USE_LIGHT;
+		// cast shadows?
+		material->ras_mode |= ( mat->mode & MA_SHADBUF )?CAST_SHADOW:0;
 		MTex *mttmp = 0;
 		numchan = getNumTexChannels(mat);
 		int valid_index = 0;
@@ -1484,7 +1486,7 @@ void BL_CreatePhysicsObjectNew(KX_GameObject* gameobj,
 		{
 			objprop.m_gamesoftFlag = OB_BSB_BENDING_CONSTRAINTS | OB_BSB_SHAPE_MATCHING | OB_BSB_AERO_VPOINT;
 			
-			objprop.m_soft_linStiff = 0.5;;
+			objprop.m_soft_linStiff = 0.5;
 			objprop.m_soft_angStiff = 1.f;		/* angular stiffness 0..1 */
 			objprop.m_soft_volume= 1.f;			/* volume preservation 0..1 */
 
@@ -1685,8 +1687,6 @@ static KX_LightObject *gamelight_from_blamp(Object *ob, Lamp *la, unsigned int l
 
 	gamelight = new KX_LightObject(kxscene, KX_Scene::m_callbacks, rendertools,
 		lightobj, glslmat);
-
-	BL_ConvertLampIpos(la, gamelight, converter);
 	
 	return gamelight;
 }
@@ -1699,8 +1699,6 @@ static KX_Camera *gamecamera_from_bcamera(Object *ob, KX_Scene *kxscene, KX_Blen
 	gamecamera= new KX_Camera(kxscene, KX_Scene::m_callbacks, camdata);
 	gamecamera->SetName(ca->id.name + 2);
 	
-	BL_ConvertCameraIpos(ca, gamecamera, converter);
-	
 	return gamecamera;
 }
 
@@ -1817,11 +1815,13 @@ static KX_GameObject *gameobject_from_blenderobject(
 	
 	case OB_ARMATURE:
 	{
+		bArmature *arm = (bArmature*)ob->data;
 		gameobj = new BL_ArmatureObject(
 			kxscene,
 			KX_Scene::m_callbacks,
 			ob,
-			kxscene->GetBlenderScene() // handle
+			kxscene->GetBlenderScene(), // handle
+			arm->gevertdeformer
 		);
 		/* Get the current pose from the armature object and apply it as the rest pose */
 		break;
@@ -1850,7 +1850,6 @@ static KX_GameObject *gameobject_from_blenderobject(
 	{
 		gameobj->SetLayer(ob->lay);
 		gameobj->SetBlenderObject(ob);
-		gameobj->SetObjectColor(ob->col);
 		/* set the visibility state based on the objects render option in the outliner */
 		if(ob->restrictflag & OB_RESTRICT_RENDER) gameobj->SetVisible(0, 0);
 	}
@@ -1922,11 +1921,11 @@ void RBJconstraints(Object *ob)//not used
 
 KX_IPhysicsController* getPhId(CListValue* sumolist,STR_String busc){//not used
 
-    for (int j=0;j<sumolist->GetCount();j++)
+	for (int j=0;j<sumolist->GetCount();j++)
 	{
-	    KX_GameObject* gameobje = (KX_GameObject*) sumolist->GetValue(j);
-	    if (gameobje->GetName()==busc)
-            return gameobje->GetPhysicsController();
+		KX_GameObject* gameobje = (KX_GameObject*) sumolist->GetValue(j);
+		if (gameobje->GetName()==busc)
+			return gameobje->GetPhysicsController();
 	}
 
 	return 0;
@@ -1935,11 +1934,11 @@ KX_IPhysicsController* getPhId(CListValue* sumolist,STR_String busc){//not used
 
 KX_GameObject* getGameOb(STR_String busc,CListValue* sumolist){
 
-    for (int j=0;j<sumolist->GetCount();j++)
+	for (int j=0;j<sumolist->GetCount();j++)
 	{
-	    KX_GameObject* gameobje = (KX_GameObject*) sumolist->GetValue(j);
-	    if (gameobje->GetName()==busc)
-            return gameobje;
+		KX_GameObject* gameobje = (KX_GameObject*) sumolist->GetValue(j);
+		if (gameobje->GetName()==busc)
+			return gameobje;
 	}
 	
 	return 0;
@@ -1987,8 +1986,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 			frame_type = RAS_FrameSettings::e_frame_scale;
 		}
 		
-		aspect_width = blenderscene->gm.xsch;
-		aspect_height = blenderscene->gm.ysch;
+		aspect_width = blenderscene->r.xsch*blenderscene->r.xasp;
+		aspect_height = blenderscene->r.ysch*blenderscene->r.yasp;
 	}
 	
 	RAS_FrameSettings frame_settings(
@@ -2101,8 +2100,7 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 			gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
 			gameobj->NodeSetLocalScale(scale);
 			gameobj->NodeUpdateGS(0);
-			
-			BL_ConvertIpos(blenderobject,gameobj,converter);
+
 			BL_ConvertMaterialIpos(blenderobject, gameobj, converter);
 			
 			sumolist->Add(gameobj->AddRef());
@@ -2291,8 +2289,7 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 							gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
 							gameobj->NodeSetLocalScale(scale);
 							gameobj->NodeUpdateGS(0);
-							
-							BL_ConvertIpos(blenderobject,gameobj,converter);
+	
 							BL_ConvertMaterialIpos(blenderobject,gameobj, converter);	
 					
 							sumolist->Add(gameobj->AddRef());
@@ -2642,7 +2639,7 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 						{
 							PHY_IPhysicsController* physctrl = (PHY_IPhysicsController*) gameobj->GetPhysicsController()->GetUserData();
 							//we need to pass a full constraint frame, not just axis
-	                            
+
 							//localConstraintFrameBasis
 							MT_Matrix3x3 localCFrame(MT_Vector3(dat->axX,dat->axY,dat->axZ));
 							MT_Vector3 axis0 = localCFrame.getColumn(0);
diff --git a/source/gameengine/Converter/BL_DeformableGameObject.cpp b/source/gameengine/Converter/BL_DeformableGameObject.cpp
index bfba054d0d4..48392ee8dda 100644
--- a/source/gameengine/Converter/BL_DeformableGameObject.cpp
+++ b/source/gameengine/Converter/BL_DeformableGameObject.cpp
@@ -87,15 +87,16 @@ bool BL_DeformableGameObject::SetActiveAction(BL_ShapeActionActuator *act, short
 bool BL_DeformableGameObject::GetShape(vector<float> &shape)
 {
 	shape.clear();
-	if (m_pDeformer)
+	BL_ShapeDeformer* shape_deformer = dynamic_cast<BL_ShapeDeformer*>(m_pDeformer);
+	if (shape_deformer)
 	{
-		Mesh* mesh = ((BL_MeshDeformer*)m_pDeformer)->GetMesh();
 		// this check is normally superfluous: a shape deformer can only be created if the mesh
 		// has relative keys
-		if (mesh && mesh->key && mesh->key->type==KEY_RELATIVE) 
+		Key* key = shape_deformer->GetKey();
+		if (key && key->type==KEY_RELATIVE) 
 		{
 			KeyBlock *kb;
-			for (kb = (KeyBlock*)mesh->key->block.first; kb; kb = (KeyBlock*)kb->next)
+			for (kb = (KeyBlock*)key->block.first; kb; kb = (KeyBlock*)kb->next)
 			{
 				shape.push_back(kb->curval);
 			}
diff --git a/source/gameengine/Converter/BL_DeformableGameObject.h b/source/gameengine/Converter/BL_DeformableGameObject.h
index 615bb84ac2b..3ba55664007 100644
--- a/source/gameengine/Converter/BL_DeformableGameObject.h
+++ b/source/gameengine/Converter/BL_DeformableGameObject.h
@@ -82,23 +82,6 @@ public:
 	bool SetActiveAction(class BL_ShapeActionActuator *act, short priority, double curtime);
 
 	bool GetShape(vector<float> &shape);
-	Key* GetKey()
-	{
-		if(m_pDeformer) {
-			BL_MeshDeformer *deformer= dynamic_cast<BL_MeshDeformer *>(m_pDeformer); // incase its not a MeshDeformer
-			if(deformer) {
-				return deformer->GetMesh()->key;
-			}
-
-#if 0		// TODO. shape keys for softbody, currently they dont store a mesh.
-			KX_SoftBodyDeformer *deformer_soft= dynamic_cast<KX_SoftBodyDeformer *>(m_pDeformer);	
-			if(deformer) {
-				return deformer->GetMesh()->key;
-			}
-#endif
-		}
-		return NULL;
-	}
 	
 	virtual void	SetDeformer(class RAS_Deformer* deformer);
 	virtual class RAS_Deformer* GetDeformer()
diff --git a/source/gameengine/Converter/BL_MeshDeformer.h b/source/gameengine/Converter/BL_MeshDeformer.h
index 90466e930fb..0968478ce7e 100644
--- a/source/gameengine/Converter/BL_MeshDeformer.h
+++ b/source/gameengine/Converter/BL_MeshDeformer.h
@@ -88,7 +88,7 @@ protected:
 	// --
 	int							m_tvtot;
 	BL_DeformableGameObject*	m_gameobj;
-	double					 	m_lastDeformUpdate;
+	double						m_lastDeformUpdate;
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Converter/BL_ShapeActionActuator.cpp b/source/gameengine/Converter/BL_ShapeActionActuator.cpp
index bb53c2d6fe6..ac377cdb7ca 100644
--- a/source/gameengine/Converter/BL_ShapeActionActuator.cpp
+++ b/source/gameengine/Converter/BL_ShapeActionActuator.cpp
@@ -59,10 +59,49 @@
 
 extern "C" {
 	#include "BKE_animsys.h"
+	#include "BKE_key.h"
+	#include "RNA_access.h"
 }
 
+BL_ShapeActionActuator::BL_ShapeActionActuator(SCA_IObject* gameobj,
+					const STR_String& propname,
+					const STR_String& framepropname,
+					float starttime,
+					float endtime,
+					struct bAction *action,
+					short	playtype,
+					short	blendin,
+					short	priority,
+					float	stride) 
+	: SCA_IActuator(gameobj, KX_ACT_SHAPEACTION),
+		
+	m_lastpos(0, 0, 0),
+	m_blendframe(0),
+	m_flag(0),
+	m_startframe (starttime),
+	m_endframe(endtime) ,
+	m_starttime(0),
+	m_localtime(starttime),
+	m_lastUpdate(-1),
+	m_blendin(blendin),
+	m_blendstart(0),
+	m_stridelength(stride),
+	m_playtype(playtype),
+	m_priority(priority),
+	m_action(action),
+	m_framepropname(framepropname),	
+	m_propname(propname)
+{
+	m_idptr = new PointerRNA();
+	BL_DeformableGameObject *obj = (BL_DeformableGameObject*)GetParent();
+	BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
+	RNA_id_pointer_create(&shape_deformer->GetKey()->id, m_idptr);
+};
+
 BL_ShapeActionActuator::~BL_ShapeActionActuator()
 {
+	if (m_idptr)
+		delete m_idptr;
 }
 
 void BL_ShapeActionActuator::ProcessReplica()
@@ -382,7 +421,11 @@ bool BL_ShapeActionActuator::Update(double curtime, bool frame)
 
 		/* Priority test */
 		if (obj->SetActiveAction(this, priority, curtime)){
-			Key *key = obj->GetKey();
+			BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
+			Key *key = NULL;
+
+			if (shape_deformer)
+				key = shape_deformer->GetKey();
 
 			if (!key) {
 				// this could happen if the mesh was changed in the middle of an action
@@ -397,10 +440,14 @@ bool BL_ShapeActionActuator::Update(double curtime, bool frame)
 					obj->GetShape(m_blendshape);
 					m_blendstart = curtime;
 				}
-				// only interested in shape channel
 
-				// in 2.4x was // extract_ipochannels_from_action(&tchanbase, &key->id, m_action, "Shape", m_localtime);
-				BKE_animsys_evaluate_animdata(&key->id, key->adt, m_localtime, ADT_RECALC_ANIM);
+				KeyBlock *kb;
+				// We go through and clear out the keyblocks so there isn't any interference
+				// from other shape actions
+				for (kb=(KeyBlock*)key->block.first; kb; kb=(KeyBlock*)kb->next)
+					kb->curval = 0.f;
+
+				animsys_evaluate_action(m_idptr, m_action, NULL, m_localtime);
 
 				// XXX - in 2.5 theres no way to do this. possibly not that important to support - Campbell
 				if (0) { // XXX !execute_ipochannels(&tchanbase)) {
diff --git a/source/gameengine/Converter/BL_ShapeActionActuator.h b/source/gameengine/Converter/BL_ShapeActionActuator.h
index 7a4523d4554..efd24fc305f 100644
--- a/source/gameengine/Converter/BL_ShapeActionActuator.h
+++ b/source/gameengine/Converter/BL_ShapeActionActuator.h
@@ -54,27 +54,7 @@ public:
 						short	playtype,
 						short	blendin,
 						short	priority,
-						float	stride) 
-		: SCA_IActuator(gameobj, KX_ACT_SHAPEACTION),
-		
-		m_lastpos(0, 0, 0),
-		m_blendframe(0),
-		m_flag(0),
-		m_startframe (starttime),
-		m_endframe(endtime) ,
-		m_starttime(0),
-		m_localtime(starttime),
-		m_lastUpdate(-1),
-		m_blendin(blendin),
-		m_blendstart(0),
-		m_stridelength(stride),
-		m_playtype(playtype),
-		m_priority(priority),
-		m_action(action),
-		m_framepropname(framepropname),	
-		m_propname(propname)
-	{
-	};
+						float	stride);
 	virtual ~BL_ShapeActionActuator();
 	virtual	bool Update(double curtime, bool frame);
 	virtual CValue* GetReplica();
@@ -160,6 +140,7 @@ protected:
 	STR_String	m_framepropname;
 	STR_String	m_propname;
 	vector<float> m_blendshape;
+	struct PointerRNA *m_idptr;
 };
 
 #endif
diff --git a/source/gameengine/Converter/BL_ShapeDeformer.cpp b/source/gameengine/Converter/BL_ShapeDeformer.cpp
index 8d8f149bb6c..f4c683f60ba 100644
--- a/source/gameengine/Converter/BL_ShapeDeformer.cpp
+++ b/source/gameengine/Converter/BL_ShapeDeformer.cpp
@@ -44,13 +44,12 @@
 #include "RAS_MeshObject.h"
 
 //#include "BL_ArmatureController.h"
+#include "DNA_anim_types.h"
 #include "DNA_armature_types.h"
 #include "DNA_action_types.h"
 #include "DNA_key_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
-#include "DNA_ipo_types.h"
-#include "DNA_curve_types.h"
 #include "BKE_armature.h"
 #include "BKE_action.h"
 #include "BKE_key.h"
@@ -59,6 +58,7 @@
 
 extern "C"{
 	#include "BKE_lattice.h"
+	#include "BKE_animsys.h"
 }
  
 
@@ -68,9 +68,42 @@ extern "C"{
 #define __NLA_DEFNORMALS
 //#undef __NLA_DEFNORMALS
 
+BL_ShapeDeformer::BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
+                                   Object *bmeshobj,
+                                   RAS_MeshObject *mesh)
+    :
+      BL_SkinDeformer(gameobj,bmeshobj, mesh),
+      m_useShapeDrivers(false),
+      m_lastShapeUpdate(-1)
+{
+	m_key = m_bmesh->key;
+	m_bmesh->key = copy_key(m_key);
+};
+
+/* this second constructor is needed for making a mesh deformable on the fly. */
+BL_ShapeDeformer::BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
+				Object *bmeshobj_old,
+				Object *bmeshobj_new,
+				RAS_MeshObject *mesh,
+				bool release_object,
+				bool recalc_normal,
+				BL_ArmatureObject* arma)
+				:
+					BL_SkinDeformer(gameobj, bmeshobj_old, bmeshobj_new, mesh, release_object, recalc_normal, arma),
+					m_useShapeDrivers(false),
+					m_lastShapeUpdate(-1)
+{
+	m_key = m_bmesh->key;
+	m_bmesh->key = copy_key(m_key);
+};
 
 BL_ShapeDeformer::~BL_ShapeDeformer()
 {
+	if (m_key && m_bmesh->key)
+	{
+		free_key(m_bmesh->key);
+		m_bmesh->key = m_key;
+	}
 };
 
 RAS_Deformer *BL_ShapeDeformer::GetReplica()
@@ -90,45 +123,23 @@ void BL_ShapeDeformer::ProcessReplica()
 
 bool BL_ShapeDeformer::LoadShapeDrivers(Object* arma)
 {
-	IpoCurve *icu;
-
-	m_shapeDrivers.clear();
-	// check if this mesh has armature driven shape keys
-	if (m_bmesh->key && m_bmesh->key->ipo) {
-		for(icu= (IpoCurve*)m_bmesh->key->ipo->curve.first; icu; icu= (IpoCurve*)icu->next) {
-			if(icu->driver && 
-				(icu->flag & IPO_MUTE) == 0 &&
-				icu->driver->type == IPO_DRIVER_TYPE_NORMAL &&
-				icu->driver->ob == arma &&
-				icu->driver->blocktype == ID_AR) {
-				// this shape key ipo curve has a driver on the parent armature
-				// record this curve in the shape deformer so that the corresponding
-				m_shapeDrivers.push_back(icu);
-			}
-		}
-	}
-	return !m_shapeDrivers.empty();
+	// This used to check if we had drivers from this armature,
+	// now we just assume we want to use shape drivers
+	// and let the animsys handle things.
+	m_useShapeDrivers = true;
+
+	return true;
 }
 
 bool BL_ShapeDeformer::ExecuteShapeDrivers(void)
 {
-	if (!m_shapeDrivers.empty() && PoseUpdated()) {
-		vector<IpoCurve*>::iterator it;
-//		void *poin;
-//		int type;
-
+	if (m_useShapeDrivers && PoseUpdated()) {
 		// the shape drivers use the bone matrix as input. Must 
 		// update the matrix now
 		m_armobj->ApplyPose();
 
-		for (it=m_shapeDrivers.begin(); it!=m_shapeDrivers.end(); it++) {
-			// no need to set a specific time: this curve has a driver
-			// XXX IpoCurve *icu = *it;
-			//calc_icu(icu, 1.0f);
-			//poin = get_ipo_poin((ID*)m_bmesh->key, icu, &type);
-			//if (poin) 
-			//	write_ipo_poin(poin, type, icu->curval);
-		}
+		// We don't need an actual time, just use 0
+		BKE_animsys_evaluate_animdata(NULL, &GetKey()->id, GetKey()->adt, 0.f, ADT_RECALC_DRIVERS);
 
 		ForceUpdate();
 		m_armobj->RestorePose();
@@ -190,3 +201,13 @@ bool BL_ShapeDeformer::Update(void)
 	}
 	return bSkinUpdate;
 }
+
+Key *BL_ShapeDeformer::GetKey()
+{
+	return m_bmesh->key;
+}
+
+void BL_ShapeDeformer::SetKey(Key *key)
+{
+	m_bmesh->key = key;
+}
diff --git a/source/gameengine/Converter/BL_ShapeDeformer.h b/source/gameengine/Converter/BL_ShapeDeformer.h
index 8115af59d27..609603ae52b 100644
--- a/source/gameengine/Converter/BL_ShapeDeformer.h
+++ b/source/gameengine/Converter/BL_ShapeDeformer.h
@@ -42,19 +42,12 @@
 #include "BL_DeformableGameObject.h"
 #include <vector>
 
-struct IpoCurve;
-
 class BL_ShapeDeformer : public BL_SkinDeformer  
 {
 public:
 	BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
-                     Object *bmeshobj,
-                     RAS_MeshObject *mesh)
-					:	
-						BL_SkinDeformer(gameobj,bmeshobj, mesh),
-						m_lastShapeUpdate(-1)
-	{
-	};
+	                 Object *bmeshobj,
+	                 RAS_MeshObject *mesh);
 
 	/* this second constructor is needed for making a mesh deformable on the fly. */
 	BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
@@ -63,12 +56,7 @@ public:
 					class RAS_MeshObject *mesh,
 					bool release_object,
 					bool recalc_normal,
-					BL_ArmatureObject* arma = NULL)
-					:
-						BL_SkinDeformer(gameobj, bmeshobj_old, bmeshobj_new, mesh, release_object, recalc_normal, arma),
-						m_lastShapeUpdate(-1)
-	{
-	};
+					BL_ArmatureObject* arma = NULL);
 
 	virtual RAS_Deformer *GetReplica();
 	virtual void ProcessReplica();
@@ -78,14 +66,18 @@ public:
 	bool LoadShapeDrivers(Object* arma);
 	bool ExecuteShapeDrivers(void);
 
+	struct Key *GetKey();
+	void SetKey(struct Key *key);
+
 	void ForceUpdate()
 	{
 		m_lastShapeUpdate = -1.0;
 	};
 
 protected:
-	vector<IpoCurve*>		 m_shapeDrivers;
-	double					 m_lastShapeUpdate;
+	bool			m_useShapeDrivers;	
+	double			m_lastShapeUpdate;
+	struct Key*		m_key;
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Converter/BL_SkinDeformer.cpp b/source/gameengine/Converter/BL_SkinDeformer.cpp
index 34f9cb56c27..98afcf877a1 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.cpp
+++ b/source/gameengine/Converter/BL_SkinDeformer.cpp
@@ -36,6 +36,10 @@
 #pragma warning (disable : 4786)
 #endif //WIN32
 
+// Eigen2 stuff used for BGEDeformVerts
+#include <Eigen/Core>
+#include <Eigen/LU>
+
 #include "BL_SkinDeformer.h"
 #include "CTR_Map.h"
 #include "STR_HashedString.h"
@@ -54,6 +58,7 @@
 
 extern "C"{
 	#include "BKE_lattice.h"
+	#include "BKE_deform.h"
 }
  
 
@@ -74,7 +79,9 @@ BL_SkinDeformer::BL_SkinDeformer(BL_DeformableGameObject *gameobj,
 							//m_defbase(&bmeshobj->defbase),
 							m_releaseobject(false),
 							m_poseApplied(false),
-							m_recalcNormal(true)
+							m_recalcNormal(true),
+							m_copyNormals(false),
+							m_dfnrToPC(NULL)
 {
 	copy_m4_m4(m_obmat, bmeshobj->obmat);
 };
@@ -92,7 +99,9 @@ BL_SkinDeformer::BL_SkinDeformer(
 		m_lastArmaUpdate(-1),
 		//m_defbase(&bmeshobj_old->defbase),
 		m_releaseobject(release_object),
-		m_recalcNormal(recalc_normal)
+		m_recalcNormal(recalc_normal),
+		m_copyNormals(false),
+		m_dfnrToPC(NULL)
 	{
 		// this is needed to ensure correct deformation of mesh:
 		// the deformation is done with Blender's armature_deform_verts() function
@@ -106,6 +115,8 @@ BL_SkinDeformer::~BL_SkinDeformer()
 {
 	if(m_releaseobject && m_armobj)
 		m_armobj->Release();
+	if(m_dfnrToPC)
+		delete [] m_dfnrToPC;
 }
 
 void BL_SkinDeformer::Relink(CTR_Map<class CTR_HashedPtr, void*>*map)
@@ -152,9 +163,14 @@ bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
 				for(i=it.startvertex; i<it.endvertex; i++) {
 					RAS_TexVert& v = it.vertex[i];
 					v.SetXYZ(m_transverts[v.getOrigIndex()]);
+					if (m_copyNormals)
+						v.SetNormal(m_transnors[v.getOrigIndex()]);
 				}
 			}
 		}
+
+		if (m_copyNormals)
+			m_copyNormals = false;
 	}
 	return true;
 }
@@ -174,19 +190,124 @@ void BL_SkinDeformer::ProcessReplica()
 	BL_MeshDeformer::ProcessReplica();
 	m_lastArmaUpdate = -1;
 	m_releaseobject = false;
+	m_dfnrToPC = NULL;
+}
+
+void BL_SkinDeformer::BlenderDeformVerts()
+{
+	float obmat[4][4];	// the original object matrix
+	Object* par_arma = m_armobj->GetArmatureObject();
+
+	// save matrix first
+	copy_m4_m4(obmat, m_objMesh->obmat);
+	// set reference matrix
+	copy_m4_m4(m_objMesh->obmat, m_obmat);
+
+	armature_deform_verts( par_arma, m_objMesh, NULL, m_transverts, NULL, m_bmesh->totvert, ARM_DEF_VGROUP, NULL, NULL );
+		
+	// restore matrix 
+	copy_m4_m4(m_objMesh->obmat, obmat);
+
+#ifdef __NLA_DEFNORMALS
+		if (m_recalcNormal)
+			RecalcNormals();
+#endif
+}
+
+void BL_SkinDeformer::BGEDeformVerts()
+{
+	Object *par_arma = m_armobj->GetArmatureObject();
+	MDeformVert *dverts = m_bmesh->dvert;
+	bDeformGroup *dg;
+	int numGroups = BLI_countlist(&m_objMesh->defbase);
+
+	if (!dverts)
+		return;
+
+	if (m_dfnrToPC == NULL)
+	{
+		m_dfnrToPC = new bPoseChannel*[numGroups];
+		int i;
+		for (i=0, dg=(bDeformGroup*)m_objMesh->defbase.first;
+			dg;
+			++i, dg=(bDeformGroup*)dg->next)
+		{
+			m_dfnrToPC[i] = get_pose_channel(par_arma->pose, dg->name);
+
+			if (m_dfnrToPC[i] && m_dfnrToPC[i]->bone->flag & BONE_NO_DEFORM)
+				m_dfnrToPC[i] = NULL;
+		}
+	}
+
+
+	for (int i=0; i<m_bmesh->totvert; ++i)
+	{
+		float contrib = 0.f, weight, max_weight=0.f;
+		bPoseChannel *pchan=NULL;
+		MDeformVert *dvert;
+		Eigen::Map<Eigen::Vector3f> norm(m_transnors[i]);
+		Eigen::Vector4f vec(0, 0, 0, 1);
+		Eigen::Matrix4f norm_chan_mat;
+		Eigen::Vector4f co(m_transverts[i][0],
+							m_transverts[i][1],
+							m_transverts[i][2],
+							1.f);
+
+		dvert = dverts+i;
+
+		if (!dvert->totweight)
+			continue;
+
+		for (int j=0; j<dvert->totweight; ++j)
+		{
+			int index = dvert->dw[j].def_nr;
+
+			if (index < numGroups && (pchan=m_dfnrToPC[index]))
+			{
+				weight = dvert->dw[j].weight;
+
+				if (weight)
+				{
+					Eigen::Vector4f cop(co);
+					Eigen::Matrix4f chan_mat = Eigen::Matrix4f::Map((float*)pchan->chan_mat);
+
+					// Update Vertex Position
+					cop = chan_mat*cop;
+					vec += (cop - co)*weight;
+
+					// Save the most influential channel so we can use it to update the vertex normal
+					if (weight > max_weight)
+					{
+						max_weight = weight;
+						norm_chan_mat = chan_mat;
+					}
+
+					contrib += weight;
+				}
+			}
+		}
+
+		
+		// Update Vertex Normal
+		norm = norm_chan_mat.corner<3, 3>(Eigen::TopLeft)*norm;
+				
+		if (contrib > 0.0001f)
+		{
+			vec *= 1.f/contrib;
+			co += vec;
+		}
+
+		m_transverts[i][0] = co[0];
+		m_transverts[i][1] = co[1];
+		m_transverts[i][2] = co[2];
+	}
+	m_copyNormals = true;
 }
 
-//void where_is_pose (Object *ob);
-//void armature_deform_verts(Object *armOb, Object *target, float (*vertexCos)[3], int numVerts, int deformflag); 
 bool BL_SkinDeformer::UpdateInternal(bool shape_applied)
 {
 	/* See if the armature has been updated for this frame */
 	if (PoseUpdated()){	
-		float obmat[4][4];	// the original object matrice 
-
-		/* XXX note: where_is_pose() (from BKE_armature.h) calculates all matrices needed to start deforming */
-		/* but it requires the blender object pointer... */
-		Object* par_arma = m_armobj->GetArmatureObject();
 
 		if(!shape_applied) {
 			/* store verts locally */
@@ -194,25 +315,23 @@ bool BL_SkinDeformer::UpdateInternal(bool shape_applied)
 		
 			/* duplicate */
 			for (int v =0; v<m_bmesh->totvert; v++)
+			{
 				VECCOPY(m_transverts[v], m_bmesh->mvert[v].co);
+				VECCOPY(m_transnors[v], m_bmesh->mvert[v].no);
+			}
 		}
 
 		m_armobj->ApplyPose();
 
-		// save matrix first
-		copy_m4_m4(obmat, m_objMesh->obmat);
-		// set reference matrix
-		copy_m4_m4(m_objMesh->obmat, m_obmat);
-
-		armature_deform_verts( par_arma, m_objMesh, NULL, m_transverts, NULL, m_bmesh->totvert, ARM_DEF_VGROUP, NULL, NULL );
-		
-		// restore matrix 
-		copy_m4_m4(m_objMesh->obmat, obmat);
-
-#ifdef __NLA_DEFNORMALS
-		if (m_recalcNormal)
-			RecalcNormals();
-#endif
+		switch (m_armobj->GetVertDeformType())
+		{
+			case ARM_VDEF_BGE_CPU:
+				BGEDeformVerts();
+				break;
+			case ARM_VDEF_BLENDER:
+			default:
+				BlenderDeformVerts();
+		}
 
 		/* Update the current frame */
 		m_lastArmaUpdate=m_armobj->GetLastFrame();
diff --git a/source/gameengine/Converter/BL_SkinDeformer.h b/source/gameengine/Converter/BL_SkinDeformer.h
index e53e21e946f..be974619281 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.h
+++ b/source/gameengine/Converter/BL_SkinDeformer.h
@@ -109,6 +109,11 @@ protected:
 	bool					m_releaseobject;
 	bool					m_poseApplied;
 	bool					m_recalcNormal;
+	bool					m_copyNormals; // dirty flag so we know if Apply() needs to copy normal information (used for BGEDeformVerts())
+	struct bPoseChannel**	m_dfnrToPC;
+
+	void BlenderDeformVerts();
+	void BGEDeformVerts();
 
 
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Converter/BlenderWorldInfo.cpp b/source/gameengine/Converter/BlenderWorldInfo.cpp
index 8fc01032de7..f003a0049e5 100644
--- a/source/gameengine/Converter/BlenderWorldInfo.cpp
+++ b/source/gameengine/Converter/BlenderWorldInfo.cpp
@@ -170,10 +170,10 @@ float BlenderWorldInfo::getMistStart()
 float BlenderWorldInfo::getMistDistance()
 {
 	return m_mistdistance;
-}  
-    
+}
+
+
 
-    
 float BlenderWorldInfo::getMistColorRed()
 {
 	return m_mistcolor[0];
diff --git a/source/gameengine/Converter/CMakeLists.txt b/source/gameengine/Converter/CMakeLists.txt
index fcb608a5830..039f454e870 100644
--- a/source/gameengine/Converter/CMakeLists.txt
+++ b/source/gameengine/Converter/CMakeLists.txt
@@ -26,37 +26,36 @@
 
 set(INC
 	.
-	../../../intern/string
-	../../../intern/guardedalloc
+	../BlenderRoutines
+	../Expressions
+	../GameLogic
+	../Ketsji
+	../Ketsji/KXNetwork
+	../Network
+	../Network/LoopBackNetwork
+	../Physics/Bullet
+	../Physics/Dummy
+	../Physics/common
+	../Rasterizer
+	../Rasterizer/RAS_OpenGLRasterizer
+	../Rasterizer/RAS_OpenGLRasterizer
+	../SceneGraph
+	../../blender
+	../../blender/blenkernel
+	../../blender/blenlib
+	../../blender/blenloader
+	../../blender/gpu
+	../../blender/ikplugin
+	../../blender/imbuf
+	../../blender/makesdna
+	../../blender/makesrna
+	../../blender/windowmanager
+	../../../extern/bullet2/src
+	../../../extern/Eigen2
 	../../../intern/container
-	../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer
-	../../../intern/audaspace/intern
-	../../../source/gameengine/Converter
-	../../../source/gameengine/BlenderRoutines
-	../../../source/blender/imbuf
+	../../../intern/guardedalloc
 	../../../intern/moto/include
-	../../../source/gameengine/Ketsji
-	../../../source/gameengine/Ketsji/KXNetwork
-	../../../source/blender/blenlib
-	../../../source/blender/blenkernel
-	../../../source/blender/windowmanager
-	../../../source/blender
-	../../../source/blender/makesdna
-	../../../source/blender/makesrna
-	../../../source/gameengine/Rasterizer
-	../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer
-	../../../source/gameengine/GameLogic
-	../../../source/gameengine/Expressions
-	../../../source/gameengine/Network
-	../../../source/gameengine/SceneGraph
-	../../../source/gameengine/Physics/common
-	../../../source/gameengine/Physics/Bullet
-	../../../source/gameengine/Physics/Dummy
-	../../../source/gameengine/Network/LoopBackNetwork
-	../../../source/blender/blenloader
-	../../../source/blender/gpu
-	../../../source/blender/ikplugin
-	../../../extern/bullet2/src
+	../../../intern/string
 	../../../extern/recastnavigation/Detour/Include
 )
 
@@ -114,4 +113,11 @@ if(WITH_BULLET)
 	add_definitions(-DUSE_BULLET)
 endif()
 
+if(WITH_AUDASPACE)
+	list(APPEND INC
+		../../../intern/audaspace/intern
+	)
+	add_definitions(-DWITH_AUDASPACE)
+endif()
+
 blender_add_lib(ge_converter "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/gameengine/Converter/KX_BlenderScalarInterpolator.cpp b/source/gameengine/Converter/KX_BlenderScalarInterpolator.cpp
index a9a3e66f996..75c0e012226 100644
--- a/source/gameengine/Converter/KX_BlenderScalarInterpolator.cpp
+++ b/source/gameengine/Converter/KX_BlenderScalarInterpolator.cpp
@@ -47,11 +47,11 @@ float BL_ScalarInterpolator::GetValue(float currentTime) const {
 	return evaluate_fcurve(m_fcu, currentTime);
 }
 
-BL_InterpolatorList::BL_InterpolatorList(struct AnimData *adt) {
-	if(adt->action==NULL)
+BL_InterpolatorList::BL_InterpolatorList(bAction *action) {
+	if(action==NULL)
 		return;
 	
-	for(FCurve *fcu= (FCurve *)adt->action->curves.first; fcu; fcu= (FCurve *)fcu->next) {
+	for(FCurve *fcu= (FCurve *)action->curves.first; fcu; fcu= (FCurve *)fcu->next) {
 		if(fcu->rna_path) {
 			BL_ScalarInterpolator *new_ipo = new BL_ScalarInterpolator(fcu); 
 			//assert(new_ipo);
diff --git a/source/gameengine/Converter/KX_BlenderScalarInterpolator.h b/source/gameengine/Converter/KX_BlenderScalarInterpolator.h
index bd786bae969..cca66b3771c 100644
--- a/source/gameengine/Converter/KX_BlenderScalarInterpolator.h
+++ b/source/gameengine/Converter/KX_BlenderScalarInterpolator.h
@@ -66,7 +66,7 @@ public:
 
 class BL_InterpolatorList : public std::vector<KX_IScalarInterpolator *> {
 public:
-	BL_InterpolatorList(struct AnimData *adt);
+	BL_InterpolatorList(struct bAction *action);
 	~BL_InterpolatorList();
 
 	KX_IScalarInterpolator *GetScalarInterpolator(const char *rna_path, int array_index);	
diff --git a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
index 58089cc4b2d..656dcfa3220 100644
--- a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
+++ b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
@@ -385,6 +385,12 @@ void KX_BlenderSceneConverter::ConvertScene(class KX_Scene* destinationscene,
 	//This cache mecanism is buggy so I leave it disable and the memory leak
 	//that would result from this is fixed in RemoveScene()
 	m_map_mesh_to_gamemesh.clear();
+
+#ifndef USE_BULLET
+	/* quiet compiler warning */
+	(void)useDbvtCulling;
+#endif
+
 }
 
 // This function removes all entities stored in the converter for that scene
@@ -566,18 +572,18 @@ void KX_BlenderSceneConverter::RegisterPolyMaterial(RAS_IPolyMaterial *polymat)
 
 
 void KX_BlenderSceneConverter::RegisterInterpolatorList(
-									BL_InterpolatorList *adtList,
-									struct AnimData *for_adt)
+									BL_InterpolatorList *actList,
+									struct bAction *for_act)
 {
-	m_map_blender_to_gameAdtList.insert(CHashedPtr(for_adt), adtList);
+	m_map_blender_to_gameAdtList.insert(CHashedPtr(for_act), actList);
 }
 
 
 
 BL_InterpolatorList *KX_BlenderSceneConverter::FindInterpolatorList(
-									struct AnimData *for_adt)
+									struct bAction *for_act)
 {
-	BL_InterpolatorList **listp = m_map_blender_to_gameAdtList[CHashedPtr(for_adt)];
+	BL_InterpolatorList **listp = m_map_blender_to_gameAdtList[CHashedPtr(for_act)];
 		
 	return listp?*listp:NULL;
 }
@@ -679,7 +685,7 @@ void	KX_BlenderSceneConverter::ResetPhysicsObjectsAnimationIpo(bool clearIpo)
 								MEM_freeN( tmpicu );
 								localDel_ipoCurve( tmpicu );
 							}
-					  	}
+						}
 					} else
 					{	ipo = NULL; // XXX add_ipo(blenderObject->id.name+2, ID_OB);
 						blenderObject->ipo = ipo;
@@ -950,7 +956,6 @@ bool KX_BlenderSceneConverter::LinkBlendFilePath(const char *path, char *group,
 
 bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const char *path, char *group, KX_Scene *scene_merge, char **err_str, short options)
 {
-	bContext *C;
 	Main *main_newlib; /* stored as a dynamic 'main' until we free it */
 	Main *main_tmp= NULL; /* created only for linking, then freed */
 	LinkNode *names = NULL;
@@ -981,12 +986,10 @@ bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const cha
 	}
 	
 	main_newlib= (Main *)MEM_callocN( sizeof(Main), "BgeMain");
-	C= CTX_create();
-	CTX_data_main_set(C, main_newlib);
 	BKE_reports_init(&reports, RPT_STORE);	
 
 	/* here appending/linking starts */
-	main_tmp = BLO_library_append_begin(C, &bpy_openlib, (char *)path);
+	main_tmp = BLO_library_append_begin(main_newlib, &bpy_openlib, (char *)path);
 
 	int totnames_dummy;
 	names = BLO_blendhandle_get_datablock_names( bpy_openlib, idcode, &totnames_dummy);
@@ -1000,11 +1003,11 @@ bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const cha
 	}
 	BLI_linklist_free(names, free);	/* free linklist *and* each node's data */
 	
-	BLO_library_append_end(C, main_tmp, &bpy_openlib, idcode, flag);
+	BLO_library_append_end(NULL, main_tmp, &bpy_openlib, idcode, flag);
 
 	/* now do another round of linking for Scenes so all actions are properly loaded */
 	if (idcode==ID_SCE && options & LIB_LOAD_LOAD_ACTIONS) {
-		main_tmp = BLO_library_append_begin(C, &bpy_openlib, (char *)path);
+		main_tmp = BLO_library_append_begin(main_newlib, &bpy_openlib, (char *)path);
 
 		int totnames_dummy;
 		names = BLO_blendhandle_get_datablock_names( bpy_openlib, ID_AC, &totnames_dummy);
@@ -1018,12 +1021,11 @@ bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const cha
 		}
 		BLI_linklist_free(names, free);	/* free linklist *and* each node's data */
 	
-		BLO_library_append_end(C, main_tmp, &bpy_openlib, ID_AC, flag);
+		BLO_library_append_end(NULL, main_tmp, &bpy_openlib, ID_AC, flag);
 	}
 	
 	BLO_blendhandle_close(bpy_openlib);
-	
-	CTX_free(C);
+
 	BKE_reports_clear(&reports);
 	/* done linking */	
 	
@@ -1087,7 +1089,7 @@ bool KX_BlenderSceneConverter::LinkBlendFile(BlendHandle *bpy_openlib, const cha
  * most are temp and NewRemoveObject frees m_map_gameobject_to_blender */
 bool KX_BlenderSceneConverter::FreeBlendFile(struct Main *maggie)
 {
-	int maggie_index;
+	int maggie_index= -1;
 	int i=0;
 
 	if(maggie==NULL)
@@ -1105,6 +1107,10 @@ bool KX_BlenderSceneConverter::FreeBlendFile(struct Main *maggie)
 		i++;
 	}
 
+	/* should never happen but just to be safe */
+	if(maggie_index == -1)
+		return false;
+
 	m_DynamicMaggie.erase(m_DynamicMaggie.begin() + maggie_index);
 	tag_main(maggie, 1);
 
diff --git a/source/gameengine/Converter/KX_BlenderSceneConverter.h b/source/gameengine/Converter/KX_BlenderSceneConverter.h
index 2340e44d288..ba919eb9592 100644
--- a/source/gameengine/Converter/KX_BlenderSceneConverter.h
+++ b/source/gameengine/Converter/KX_BlenderSceneConverter.h
@@ -113,8 +113,8 @@ public:
 
 	void RegisterBlenderMaterial(BL_Material *mat);
 	
-	void RegisterInterpolatorList(BL_InterpolatorList *adtList, struct AnimData *for_adt);
-	BL_InterpolatorList *FindInterpolatorList(struct AnimData *for_adt);
+	void RegisterInterpolatorList(BL_InterpolatorList *actList, struct bAction *for_act);
+	BL_InterpolatorList *FindInterpolatorList(struct bAction *for_act);
 
 	void RegisterGameActuator(SCA_IActuator *act, struct bActuator *for_actuator);
 	SCA_IActuator *FindGameActuator(struct bActuator *for_actuator);
diff --git a/source/gameengine/Converter/KX_ConvertActuators.cpp b/source/gameengine/Converter/KX_ConvertActuators.cpp
index a8d5ab0b2ff..c73ffc2b932 100644
--- a/source/gameengine/Converter/KX_ConvertActuators.cpp
+++ b/source/gameengine/Converter/KX_ConvertActuators.cpp
@@ -43,7 +43,12 @@
 
 #include "KX_BlenderSceneConverter.h"
 #include "KX_ConvertActuators.h"
-#include "AUD_C-API.h"
+
+#ifdef WITH_AUDASPACE
+#  include "AUD_C-API.h"
+#  include "AUD_ChannelMapperFactory.h"
+#endif
+
 // Actuators
 //SCA logiclibrary native logicbricks
 #include "SCA_PropertyActuator.h"
@@ -78,6 +83,7 @@
 /* This little block needed for linking to Blender... */
 #include "BKE_text.h"
 #include "BLI_blenlib.h"
+#include "BLI_math_base.h"
 
 #define FILE_MAX 240 // repeated here to avoid dependency from BKE_utildefines.h
 
@@ -96,6 +102,7 @@
 #include "BL_ShapeActionActuator.h"
 #include "BL_ArmatureActuator.h"
 #include "RNA_access.h"
+#include "BL_Action.h"
 /* end of blender include block */
 
 #include "BL_BlenderDataConversion.h"
@@ -193,30 +200,37 @@ void BL_ConvertActuators(char* maggiename,
 			}
 		case ACT_ACTION:
 			{
-				if (blenderobject->type==OB_ARMATURE){
-					bActionActuator* actact = (bActionActuator*) bact->data;
-					STR_String propname = (actact->name ? actact->name : "");
-					STR_String propframe = (actact->frameProp ? actact->frameProp : "");
+				bActionActuator* actact = (bActionActuator*) bact->data;
+				STR_String propname = (actact->name ? actact->name : "");
+				STR_String propframe = (actact->frameProp ? actact->frameProp : "");
+
+				short ipo_flags = 0;
+
+				// Convert flags
+				if (actact->flag & ACT_IPOFORCE) ipo_flags |= BL_Action::ACT_IPOFLAG_FORCE;
+				if (actact->flag & ACT_IPOLOCAL) ipo_flags |= BL_Action::ACT_IPOFLAG_LOCAL;
+				if (actact->flag & ACT_IPOADD) ipo_flags |= BL_Action::ACT_IPOFLAG_ADD;
+				if (actact->flag & ACT_IPOCHILD) ipo_flags |= BL_Action::ACT_IPOFLAG_CHILD;
 					
-					BL_ActionActuator* tmpbaseact = new BL_ActionActuator(
-						gameobj,
-						propname,
-						propframe,
-						actact->sta,
-						actact->end,
-						actact->act,
-						actact->type, // + 1, because Blender starts to count at zero,
-						actact->blendin,
-						actact->priority,
-						actact->end_reset,
-						actact->stridelength
-						// Ketsji at 1, because zero is reserved for "NoDef"
-						);
-					baseact= tmpbaseact;
-					break;
-				}
-				else
-					printf ("Discarded action actuator from non-armature object [%s]\n", blenderobject->id.name+2);
+				BL_ActionActuator* tmpbaseact = new BL_ActionActuator(
+					gameobj,
+					propname,
+					propframe,
+					actact->sta,
+					actact->end,
+					actact->act,
+					actact->type, // + 1, because Blender starts to count at zero,
+					actact->blendin,
+					actact->priority,
+					actact->layer,
+					actact->layer_weight,
+					ipo_flags,
+					actact->end_reset,
+					actact->stridelength
+					// Ketsji at 1, because zero is reserved for "NoDef"
+					);
+				baseact= tmpbaseact;
+				break;
 			}
 		case ACT_SHAPEACTION:
 			{
@@ -288,7 +302,8 @@ void BL_ConvertActuators(char* maggiename,
 						camact->height,
 						camact->min,
 						camact->max,
-						camact->axis=='x');
+						camact->axis=='x',
+						camact->damping);
 					baseact = tmpcamact;
 				}
 				break;
@@ -376,7 +391,7 @@ void BL_ConvertActuators(char* maggiename,
 				{
 					bSound* sound = soundact->sound;
 					bool is3d = soundact->flag & ACT_SND_3D_SOUND ? true : false;
-					AUD_Sound* snd_sound = NULL;
+					AUD_Reference<AUD_IFactory> snd_sound;
 					KX_3DSoundSettings settings;
 					settings.cone_inner_angle = soundact->sound3D.cone_inner_angle;
 					settings.cone_outer_angle = soundact->sound3D.cone_outer_angle;
@@ -394,12 +409,28 @@ void BL_ConvertActuators(char* maggiename,
 										"\" has no sound datablock." << std::endl;
 					}
 					else
-						snd_sound = sound->playback_handle;
+					{
+						snd_sound = *reinterpret_cast<AUD_Reference<AUD_IFactory>*>(sound->playback_handle);
+
+						// if sound shall be 3D but isn't mono, we have to make it mono!
+						if(is3d)
+						{
+							AUD_Reference<AUD_IReader> reader = snd_sound->createReader();
+							if(reader->getSpecs().channels != AUD_CHANNELS_MONO)
+							{
+								AUD_DeviceSpecs specs;
+								specs.channels = AUD_CHANNELS_MONO;
+								specs.rate = AUD_RATE_INVALID;
+								specs.format = AUD_FORMAT_INVALID;
+								snd_sound = new AUD_ChannelMapperFactory(snd_sound, specs);
+							}
+						}
+					}
 					KX_SoundActuator* tmpsoundact =
 						new KX_SoundActuator(gameobj,
 						snd_sound,
 						soundact->volume,
-						(float)(exp((soundact->pitch / 12.0) * log(2.0))),
+						(float)(exp((soundact->pitch / 12.0) * M_LN2)),
 						is3d,
 						settings,
 						soundActuatorType);
@@ -913,7 +944,7 @@ void BL_ConvertActuators(char* maggiename,
 		case ACT_2DFILTER:
 		{
 			bTwoDFilterActuator *_2dfilter = (bTwoDFilterActuator*) bact->data;
-            SCA_2DFilterActuator *tmp = NULL;
+			SCA_2DFilterActuator *tmp = NULL;
 
 			RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode;
 			switch(_2dfilter->type)
@@ -967,7 +998,7 @@ void BL_ConvertActuators(char* maggiename,
 					filtermode = RAS_2DFilterManager::RAS_2DFILTER_NOFILTER;
 					break;
 			}
-            
+
 			tmp = new SCA_2DFilterActuator(gameobj, filtermode, _2dfilter->flag,
 				_2dfilter->float_arg,_2dfilter->int_arg,ketsjiEngine->GetRasterizer(),scene);
 
@@ -983,8 +1014,8 @@ void BL_ConvertActuators(char* maggiename,
 				}
 			}
 
-            baseact = tmp;
-			
+			baseact = tmp;
+
 		}
 		break;
 		case ACT_PARENT:
diff --git a/source/gameengine/Converter/KX_ConvertControllers.cpp b/source/gameengine/Converter/KX_ConvertControllers.cpp
index 98afc3a690a..fafaaf5cef6 100644
--- a/source/gameengine/Converter/KX_ConvertControllers.cpp
+++ b/source/gameengine/Converter/KX_ConvertControllers.cpp
@@ -210,7 +210,11 @@ void BL_ConvertControllers(
 			CIntValue* uniqueval = new CIntValue(uniqueint);
 			uniquename += uniqueval->GetText();
 			uniqueval->Release();
-			gamecontroller->SetName(uniquename);
+			//unique name was never implemented for sensors and actuators, only for controllers
+			//and it's producing difference in the keys for the lists: obj.controllers/sensors/actuators
+			//at some point it should either be implemented globally (and saved as a separate var) or removed.
+			//gamecontroller->SetName(uniquename);
+			gamecontroller->SetName(bcontr->name);
 			gameobj->AddController(gamecontroller);
 			
 			converter->RegisterGameController(gamecontroller, bcontr);
diff --git a/source/gameengine/Converter/KX_ConvertSensors.cpp b/source/gameengine/Converter/KX_ConvertSensors.cpp
index ad6941dcdc7..a250bc6064b 100644
--- a/source/gameengine/Converter/KX_ConvertSensors.cpp
+++ b/source/gameengine/Converter/KX_ConvertSensors.cpp
@@ -276,7 +276,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 		gReverseKeyTranslateTable[ENDKEY			] = SCA_IInputDevice::KX_ENDKEY;
 	}
 
-    int executePriority = 0;
+	int executePriority = 0;
 	int uniqueint = 0;
 	int count = 0;
 	bSensor* sens = (bSensor*)blenderobject->sensors.first;
diff --git a/source/gameengine/Converter/KX_IpoConvert.cpp b/source/gameengine/Converter/KX_IpoConvert.cpp
index 2ad56717e26..b13dbe324f5 100644
--- a/source/gameengine/Converter/KX_IpoConvert.cpp
+++ b/source/gameengine/Converter/KX_IpoConvert.cpp
@@ -54,6 +54,7 @@
 
 #include "DNA_object_types.h"
 #include "DNA_action_types.h"
+#include "DNA_anim_types.h"
 #include "DNA_ipo_types.h"
 #include "DNA_lamp_types.h"
 #include "DNA_world_types.h"
@@ -72,226 +73,226 @@
 
 #include "STR_HashedString.h"
 
-static BL_InterpolatorList *GetAdtList(struct AnimData *for_adt, KX_BlenderSceneConverter *converter) {
-	BL_InterpolatorList *adtList= converter->FindInterpolatorList(for_adt);
+static BL_InterpolatorList *GetAdtList(struct bAction *for_act, KX_BlenderSceneConverter *converter) {
+	BL_InterpolatorList *adtList= converter->FindInterpolatorList(for_act);
 
 	if (!adtList) {		
-		adtList = new BL_InterpolatorList(for_adt);
-		converter->RegisterInterpolatorList(adtList, for_adt);
+		adtList = new BL_InterpolatorList(for_act);
+		converter->RegisterInterpolatorList(adtList, for_act);
 	}
 			
 	return adtList;	
 }
 
-void BL_ConvertIpos(struct Object* blenderobject,KX_GameObject* gameobj,KX_BlenderSceneConverter *converter)
+SG_Controller *BL_CreateIPO(struct bAction *action, KX_GameObject* gameobj, KX_BlenderSceneConverter *converter)
 {
-	if (blenderobject->adt) {
-
-		KX_IpoSGController* ipocontr = new KX_IpoSGController();
-		gameobj->GetSGNode()->AddSGController(ipocontr);
-		ipocontr->SetObject(gameobj->GetSGNode());
-		
-		// For ipo_as_force, we need to know which SM object and Scene the
-		// object associated with this ipo is in. Is this already known here?
-		// I think not.... then it must be done later :(
-//		ipocontr->SetSumoReference(gameobj->GetSumoScene(), 
-//								   gameobj->GetSumoObject());
-
-		ipocontr->SetGameObject(gameobj);
-
-		ipocontr->GetIPOTransform().SetPosition(
-			MT_Point3(
-			blenderobject->loc[0]/*+blenderobject->dloc[0]*/,
-			blenderobject->loc[1]/*+blenderobject->dloc[1]*/,
-			blenderobject->loc[2]/*+blenderobject->dloc[2]*/
-			)
-		);
-		ipocontr->GetIPOTransform().SetEulerAngles(
-			MT_Vector3(
-			blenderobject->rot[0],
-			blenderobject->rot[1],
-			blenderobject->rot[2]
-			)
-		);
-		ipocontr->GetIPOTransform().SetScaling(
-			MT_Vector3(
-			blenderobject->size[0],
-			blenderobject->size[1],
-			blenderobject->size[2]
-			)
-		);
-
-		const char *rotmode, *drotmode;
-
-		switch(blenderobject->rotmode)
-		{
-		case ROT_MODE_AXISANGLE:
-			rotmode = "rotation_axis_angle";
-			drotmode = "delta_rotation_axis_angle";
-		case ROT_MODE_QUAT:
-			rotmode = "rotation_quaternion";
-			drotmode = "delta_rotation_quaternion";
-		default:
-			rotmode = "rotation_euler";
-			drotmode = "delta_rotation_euler";
-		}
+	KX_IpoSGController* ipocontr = new KX_IpoSGController();
+	ipocontr->SetGameObject(gameobj);
+
+	Object* blenderobject = gameobj->GetBlenderObject();
+
+	ipocontr->GetIPOTransform().SetPosition(MT_Point3(blenderobject->loc));
+	ipocontr->GetIPOTransform().SetEulerAngles(MT_Vector3(blenderobject->rot));
+	ipocontr->GetIPOTransform().SetScaling(MT_Vector3(blenderobject->size));
+
+	const char *rotmode, *drotmode;
+
+	switch(blenderobject->rotmode) {
+	case ROT_MODE_AXISANGLE:
+		rotmode = "rotation_axis_angle";
+		drotmode = "delta_rotation_axis_angle";
+		break;
+	case ROT_MODE_QUAT:
+		rotmode = "rotation_quaternion";
+		drotmode = "delta_rotation_quaternion";
+		break;
+	default:
+		rotmode = "rotation_euler";
+		drotmode = "delta_rotation_euler";
+		break;
+	}
 
-		BL_InterpolatorList *adtList= GetAdtList(blenderobject->adt, converter);
+	BL_InterpolatorList *adtList= GetAdtList(action, converter);
 		
-		// For each active channel in the adtList add an
-		// interpolator to the game object.
+	// For each active channel in the adtList add an
+	// interpolator to the game object.
 		
-		KX_IInterpolator *interpolator;
-		KX_IScalarInterpolator *interp;
+	KX_IInterpolator *interpolator;
+	KX_IScalarInterpolator *interp;
 		
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator("location", i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetPosition()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_LOC_X+i, true);
-			}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator("location", i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetPosition()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_LOC_X+i, true);
 		}
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator("delta_location", i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaPosition()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_DLOC_X+i, true);
-			}
+	}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator("delta_location", i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaPosition()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_DLOC_X+i, true);
 		}
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator(rotmode, i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetEulerAngles()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_ROT_X+i, true);
-			}
+	}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator(rotmode, i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetEulerAngles()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_ROT_X+i, true);
 		}
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator(drotmode, i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaEulerAngles()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_DROT_X+i, true);
-			}
+	}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator(drotmode, i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaEulerAngles()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_DROT_X+i, true);
 		}
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator("scale", i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetScaling()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_SIZE_X+i, true);
-			}
+	}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator("scale", i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetScaling()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_SIZE_X+i, true);
 		}
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator("delta_scale", i))) {
-				interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaScaling()[i]), interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetIPOChannelActive(OB_DSIZE_X+i, true);
-			}
+	}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator("delta_scale", i))) {
+			interpolator= new KX_ScalarInterpolator(&(ipocontr->GetIPOTransform().GetDeltaScaling()[i]), interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetIPOChannelActive(OB_DSIZE_X+i, true);
 		}
+	}
 		
-		{
-			KX_ObColorIpoSGController* ipocontr_obcol=NULL;
+	{
+		KX_ObColorIpoSGController* ipocontr_obcol=NULL;
 			
-			for(int i=0; i<4; i++) {
-				if ((interp = adtList->GetScalarInterpolator("color", i))) {
-					if (!ipocontr_obcol) {
-						ipocontr_obcol = new KX_ObColorIpoSGController();
-						gameobj->GetSGNode()->AddSGController(ipocontr_obcol);
-						ipocontr_obcol->SetObject(gameobj->GetSGNode());
-					}
-					interpolator= new KX_ScalarInterpolator(&ipocontr_obcol->m_rgba[i], interp);
-					ipocontr_obcol->AddInterpolator(interpolator);
+		for(int i=0; i<4; i++) {
+			if ((interp = adtList->GetScalarInterpolator("color", i))) {
+				if (!ipocontr_obcol) {
+					ipocontr_obcol = new KX_ObColorIpoSGController();
+					gameobj->GetSGNode()->AddSGController(ipocontr_obcol);
+					ipocontr_obcol->SetObject(gameobj->GetSGNode());
 				}
+				interpolator= new KX_ScalarInterpolator(&ipocontr_obcol->m_rgba[i], interp);
+				ipocontr_obcol->AddInterpolator(interpolator);
 			}
 		}
 	}
+
+	return ipocontr;
 }
 
-void BL_ConvertLampIpos(struct Lamp* blenderlamp, KX_GameObject *lightobj,KX_BlenderSceneConverter *converter)
+void BL_ConvertIpos(struct Object* blenderobject,KX_GameObject* gameobj,KX_BlenderSceneConverter *converter)
 {
+	if (blenderobject->adt) {
+		SG_Controller *ipocontr = BL_CreateIPO(blenderobject->adt->action, gameobj, converter);
+		gameobj->GetSGNode()->AddSGController(ipocontr);
+		ipocontr->SetObject(gameobj->GetSGNode());
+	}
+}
 
-	if (blenderlamp->adt) {
+SG_Controller *BL_CreateLampIPO(struct bAction *action, KX_GameObject*  lightobj, KX_BlenderSceneConverter *converter)
+{
+	KX_LightIpoSGController* ipocontr = new KX_LightIpoSGController();
 
-		KX_LightIpoSGController* ipocontr = new KX_LightIpoSGController();
-		lightobj->GetSGNode()->AddSGController(ipocontr);
-		ipocontr->SetObject(lightobj->GetSGNode());
-		
-		ipocontr->m_energy = blenderlamp->energy;
-		ipocontr->m_col_rgb[0] = blenderlamp->r;
-		ipocontr->m_col_rgb[1] = blenderlamp->g;
-		ipocontr->m_col_rgb[2] = blenderlamp->b;
-		ipocontr->m_dist = blenderlamp->dist;
+	Lamp *blenderlamp = (Lamp*)lightobj->GetBlenderObject()->data;
 
-		BL_InterpolatorList *adtList= GetAdtList(blenderlamp->adt, converter);
+	ipocontr->m_energy = blenderlamp->energy;
+	ipocontr->m_col_rgb[0] = blenderlamp->r;
+	ipocontr->m_col_rgb[1] = blenderlamp->g;
+	ipocontr->m_col_rgb[2] = blenderlamp->b;
+	ipocontr->m_dist = blenderlamp->dist;
 
-		// For each active channel in the adtList add an
-		// interpolator to the game object.
+	BL_InterpolatorList *adtList= GetAdtList(action, converter);
+
+	// For each active channel in the adtList add an
+	// interpolator to the game object.
 		
-		KX_IInterpolator *interpolator;
-		KX_IScalarInterpolator *interp;
+	KX_IInterpolator *interpolator;
+	KX_IScalarInterpolator *interp;
 		
-		if ((interp= adtList->GetScalarInterpolator("energy", 0))) {
-			interpolator= new KX_ScalarInterpolator(&ipocontr->m_energy, interp);
-			ipocontr->AddInterpolator(interpolator);
-			ipocontr->SetModifyEnergy(true);
-		}
+	if ((interp= adtList->GetScalarInterpolator("energy", 0))) {
+		interpolator= new KX_ScalarInterpolator(&ipocontr->m_energy, interp);
+		ipocontr->AddInterpolator(interpolator);
+		ipocontr->SetModifyEnergy(true);
+	}
 
-		if ((interp = adtList->GetScalarInterpolator("distance", 0))) {
-			interpolator= new KX_ScalarInterpolator(&ipocontr->m_dist, interp);
-			ipocontr->AddInterpolator(interpolator);
-			ipocontr->SetModifyDist(true);
-		}
+	if ((interp = adtList->GetScalarInterpolator("distance", 0))) {
+		interpolator= new KX_ScalarInterpolator(&ipocontr->m_dist, interp);
+		ipocontr->AddInterpolator(interpolator);
+		ipocontr->SetModifyDist(true);
+	}
 		
-		for(int i=0; i<3; i++) {
-			if ((interp = adtList->GetScalarInterpolator("color", i))) {
-				interpolator= new KX_ScalarInterpolator(&ipocontr->m_col_rgb[i], interp);
-				ipocontr->AddInterpolator(interpolator);
-				ipocontr->SetModifyColor(true);
-			}
+	for(int i=0; i<3; i++) {
+		if ((interp = adtList->GetScalarInterpolator("color", i))) {
+			interpolator= new KX_ScalarInterpolator(&ipocontr->m_col_rgb[i], interp);
+			ipocontr->AddInterpolator(interpolator);
+			ipocontr->SetModifyColor(true);
 		}
 	}
+
+	return ipocontr;
 }
 
+void BL_ConvertLampIpos(struct Lamp* blenderlamp, KX_GameObject *lightobj,KX_BlenderSceneConverter *converter)
+{
 
+	if (blenderlamp->adt) {
 
+		SG_Controller* ipocontr = BL_CreateLampIPO(blenderlamp->adt->action, lightobj, converter);
+		lightobj->GetSGNode()->AddSGController(ipocontr);
+		ipocontr->SetObject(lightobj->GetSGNode());
+		
+		
+	}
+}
 
-void BL_ConvertCameraIpos(struct Camera* blendercamera, KX_GameObject *cameraobj,KX_BlenderSceneConverter *converter)
+SG_Controller *BL_CreateCameraIPO(struct bAction *action, KX_GameObject*  cameraobj, KX_BlenderSceneConverter *converter)
 {
+	KX_CameraIpoSGController* ipocontr = new KX_CameraIpoSGController();
 
-	if (blendercamera->adt) {
+	Camera *blendercamera = (Camera*)cameraobj->GetBlenderObject()->data;
 
-		KX_CameraIpoSGController* ipocontr = new KX_CameraIpoSGController();
-		cameraobj->GetSGNode()->AddSGController(ipocontr);
-		ipocontr->SetObject(cameraobj->GetSGNode());
-		
-		ipocontr->m_lens = blendercamera->lens;
-		ipocontr->m_clipstart = blendercamera->clipsta;
-		ipocontr->m_clipend = blendercamera->clipend;
+	ipocontr->m_lens = blendercamera->lens;
+	ipocontr->m_clipstart = blendercamera->clipsta;
+	ipocontr->m_clipend = blendercamera->clipend;
 
-		BL_InterpolatorList *adtList= GetAdtList(blendercamera->adt, converter);
+	BL_InterpolatorList *adtList= GetAdtList(action, converter);
 
-		// For each active channel in the adtList add an
-		// interpolator to the game object.
+	// For each active channel in the adtList add an
+	// interpolator to the game object.
 		
-		KX_IInterpolator *interpolator;
-		KX_IScalarInterpolator *interp;
+	KX_IInterpolator *interpolator;
+	KX_IScalarInterpolator *interp;
 		
-		if ((interp = adtList->GetScalarInterpolator("lens", 0))) {
-			interpolator= new KX_ScalarInterpolator(&ipocontr->m_lens, interp);
-			ipocontr->AddInterpolator(interpolator);
-			ipocontr->SetModifyLens(true);
-		}
+	if ((interp = adtList->GetScalarInterpolator("lens", 0))) {
+		interpolator= new KX_ScalarInterpolator(&ipocontr->m_lens, interp);
+		ipocontr->AddInterpolator(interpolator);
+		ipocontr->SetModifyLens(true);
+	}
 
-		if ((interp = adtList->GetScalarInterpolator("clip_start", 0))) {
-			interpolator= new KX_ScalarInterpolator(&ipocontr->m_clipstart, interp);
-			ipocontr->AddInterpolator(interpolator);
-			ipocontr->SetModifyClipStart(true);
-		}
+	if ((interp = adtList->GetScalarInterpolator("clip_start", 0))) {
+		interpolator= new KX_ScalarInterpolator(&ipocontr->m_clipstart, interp);
+		ipocontr->AddInterpolator(interpolator);
+		ipocontr->SetModifyClipStart(true);
+	}
 
-		if ((interp = adtList->GetScalarInterpolator("clip_end", 0))) {
-			interpolator= new KX_ScalarInterpolator(&ipocontr->m_clipend, interp);
-			ipocontr->AddInterpolator(interpolator);
-			ipocontr->SetModifyClipEnd(true);
-		}
+	if ((interp = adtList->GetScalarInterpolator("clip_end", 0))) {
+		interpolator= new KX_ScalarInterpolator(&ipocontr->m_clipend, interp);
+		ipocontr->AddInterpolator(interpolator);
+		ipocontr->SetModifyClipEnd(true);
+	}
+
+	return ipocontr;
+}
 
+void BL_ConvertCameraIpos(struct Camera* blendercamera, KX_GameObject *cameraobj,KX_BlenderSceneConverter *converter)
+{
+
+	if (blendercamera->adt) {
+		SG_Controller* ipocontr = BL_CreateCameraIPO(blendercamera->adt->action, cameraobj, converter);
+		cameraobj->GetSGNode()->AddSGController(ipocontr);
+		ipocontr->SetObject(cameraobj->GetSGNode());
 	}
 }
 
@@ -314,7 +315,7 @@ void BL_ConvertWorldIpos(struct World* blenderworld,KX_BlenderSceneConverter *co
 		ipocontr->m_mist_rgb[1] = blenderworld->horg;
 		ipocontr->m_mist_rgb[2] = blenderworld->horb;
 
-		BL_InterpolatorList *adtList= GetAdtList(blenderworld->adt, converter);
+		BL_InterpolatorList *adtList= GetAdtList(blenderworld->adt->action, converter);
 
 		// For each active channel in the adtList add an
 		// interpolator to the game object.
@@ -356,7 +357,7 @@ static void ConvertMaterialIpos(
 		gameobj->GetSGNode()->AddSGController(ipocontr);
 		ipocontr->SetObject(gameobj->GetSGNode());
 		
-		BL_InterpolatorList *adtList= GetAdtList(blendermaterial->adt, converter);
+		BL_InterpolatorList *adtList= GetAdtList(blendermaterial->adt->action, converter);
 
 
 		ipocontr->m_rgba[0]	= blendermaterial->r;
diff --git a/source/gameengine/Converter/KX_IpoConvert.h b/source/gameengine/Converter/KX_IpoConvert.h
index d77a72a82e2..60e695c68a7 100644
--- a/source/gameengine/Converter/KX_IpoConvert.h
+++ b/source/gameengine/Converter/KX_IpoConvert.h
@@ -36,10 +36,18 @@
 
 struct Object;
 
+class SG_Controller *BL_CreateIPO(struct bAction *action,
+	class KX_GameObject* gameobj,
+	class KX_BlenderSceneConverter *converter);
+
 void BL_ConvertIpos(struct Object* blenderobject,
 	class KX_GameObject* gameobj, 
 	class KX_BlenderSceneConverter *converter);
 
+class SG_Controller *BL_CreateLampIPO(struct bAction *action,
+	class KX_GameObject* lightobj,
+	class KX_BlenderSceneConverter *converter);
+
 void BL_ConvertLampIpos(struct Lamp* blenderlight,
 	class KX_GameObject* lightobj, 
 	class KX_BlenderSceneConverter *converter);
@@ -47,6 +55,10 @@ void BL_ConvertLampIpos(struct Lamp* blenderlight,
 void BL_ConvertWorldIpos(struct World* blenderworld, 
 	class KX_BlenderSceneConverter *converter);
 
+class SG_Controller *BL_CreateCameraIPO(struct bAction *action,
+	class KX_GameObject* cameraobj,
+	class KX_BlenderSceneConverter *converter);
+
 void BL_ConvertCameraIpos(struct Camera* blendercamera,
 	class KX_GameObject* cameraobj, 
 	class KX_BlenderSceneConverter *converter);
diff --git a/source/gameengine/Converter/SConscript b/source/gameengine/Converter/SConscript
index edcd40e23ff..e155677e522 100644
--- a/source/gameengine/Converter/SConscript
+++ b/source/gameengine/Converter/SConscript
@@ -21,6 +21,7 @@ incs += ' #source/blender/windowmanager'
 incs += ' #source/blender/makesrna'
 incs += ' #source/blender/ikplugin'
 incs += ' #extern/recastnavigation/Detour/Include'
+incs += ' #extern/Eigen2'
 
 incs += ' ' + env['BF_BULLET_INC']
 
diff --git a/source/gameengine/Expressions/CMakeLists.txt b/source/gameengine/Expressions/CMakeLists.txt
index 83d44e1b318..ad987091790 100644
--- a/source/gameengine/Expressions/CMakeLists.txt
+++ b/source/gameengine/Expressions/CMakeLists.txt
@@ -26,11 +26,11 @@
 
 set(INC
 	.
-	../../../intern/string
+	../SceneGraph
+	../../blender/blenloader
 	../../../intern/guardedalloc
 	../../../intern/moto/include
-	../../../source/gameengine/SceneGraph
-	../../../source/blender/blenloader
+	../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Expressions/InputParser.cpp b/source/gameengine/Expressions/InputParser.cpp
index 7957c82e7f9..27f4f0b10cb 100644
--- a/source/gameengine/Expressions/InputParser.cpp
+++ b/source/gameengine/Expressions/InputParser.cpp
@@ -192,89 +192,89 @@ void CParser::NextSym()
 
 	switch(ch)
 	{
-    case '(':
-		sym = lbracksym; NextCh();
-		break;
-    case ')':
-		sym = rbracksym; NextCh();
-		break;
-    case ',':
-		sym = commasym; NextCh();
-		break;
-	case '%' :
-		sym = opsym; opkind = OPmodulus; NextCh();
-		break;
-    case '+' :
-		sym = opsym; opkind = OPplus; NextCh();
-		break;
-    case '-' :
-		sym = opsym; opkind = OPminus; NextCh();
-		break;
-    case '*' :
-		sym = opsym; opkind = OPtimes; NextCh();
-		break;
-    case '/' :
-		sym = opsym; opkind = OPdivide; NextCh();
-		break;
-	case '&' :
-		sym = opsym; opkind = OPand; NextCh(); TermChar('&');
-		break;
-	case '|' :
-		sym = opsym; opkind = OPor; NextCh(); TermChar('|');
-		break;
-	case '=' :
-		sym = opsym; opkind = OPequal; NextCh(); TermChar('=');
-		break;
-	case '!' :
-		sym = opsym;
-		NextCh();
-		if (ch == '=')
-		{
-			opkind = OPunequal;
+		case '(':
+			sym = lbracksym; NextCh();
+			break;
+		case ')':
+			sym = rbracksym; NextCh();
+			break;
+		case ',':
+			sym = commasym; NextCh();
+			break;
+		case '%' :
+			sym = opsym; opkind = OPmodulus; NextCh();
+			break;
+		case '+' :
+			sym = opsym; opkind = OPplus; NextCh();
+			break;
+		case '-' :
+			sym = opsym; opkind = OPminus; NextCh();
+			break;
+		case '*' :
+			sym = opsym; opkind = OPtimes; NextCh();
+			break;
+		case '/' :
+			sym = opsym; opkind = OPdivide; NextCh();
+			break;
+		case '&' :
+			sym = opsym; opkind = OPand; NextCh(); TermChar('&');
+			break;
+		case '|' :
+			sym = opsym; opkind = OPor; NextCh(); TermChar('|');
+			break;
+		case '=' :
+			sym = opsym; opkind = OPequal; NextCh(); TermChar('=');
+			break;
+		case '!' :
+			sym = opsym;
 			NextCh();
-		}
-		else
-		{
-			opkind = OPnot;
-		}
-		break;
-	case '>':
-		sym = opsym;
-		NextCh();
-		if (ch == '=')
-		{
-			opkind = OPgreaterequal;
+			if (ch == '=')
+			{
+				opkind = OPunequal;
+				NextCh();
+			}
+			else
+			{
+				opkind = OPnot;
+			}
+			break;
+		case '>':
+			sym = opsym;
 			NextCh();
-		}
-		else
-		{
-			opkind = OPgreater;
-		}
-		break;
-	case '<':
-		sym = opsym;
-		NextCh();
-		if (ch == '=') {
-			opkind = OPlessequal;
+			if (ch == '=')
+			{
+				opkind = OPgreaterequal;
+				NextCh();
+			}
+			else
+			{
+				opkind = OPgreater;
+			}
+			break;
+		case '<':
+			sym = opsym;
 			NextCh();
-		} else {
-			opkind = OPless;
-		}
-		break;
-    case '\"' : {
-		int start;
-		sym = constsym;
-		constkind = stringtype;
-		NextCh();
-		start = chcount;
-		while ((ch != '\"') && (ch != 0x0))
+			if (ch == '=') {
+				opkind = OPlessequal;
+				NextCh();
+			} else {
+				opkind = OPless;
+			}
+			break;
+		case '\"' : {
+			int start;
+			sym = constsym;
+			constkind = stringtype;
 			NextCh();
-		GrabRealString(start);
-		TermChar('\"');	// check for eol before '\"'
-		break;
-				}
-    case 0x0: sym = eolsym; break;
-    default: 
+			start = chcount;
+			while ((ch != '\"') && (ch != 0x0))
+				NextCh();
+			GrabRealString(start);
+			TermChar('\"');	// check for eol before '\"'
+			break;
+		}
+		case 0x0: sym = eolsym; break;
+		default:
 		{
 			int start;
 			start = chcount;
@@ -301,7 +301,7 @@ void CParser::NextSym()
 				}
 				GrabString(start);
 			} else if (((ch >= 'a') && (ch <= 'z'))
-				|| ((ch >= 'A') && (ch <= 'Z')))
+			           || ((ch >= 'A') && (ch <= 'Z')))
 			{ // reserved word?
 				
 				start = chcount;
@@ -358,18 +358,18 @@ STR_String CParser::Symbol2Str(int s) {
 	// returns a string representation of of symbol s,
 	// for use in Term when generating an error
 	switch(s) {
-    case errorsym: return "error";
-    case lbracksym: return "(";
-    case rbracksym: return ")";
-    case commasym: return ",";
-    case opsym: return "operator";
-    case constsym: return "constant";
-	case sumsym: return "SUM";
-	case ifsym: return "IF";
-	case whocodedsym: return "WHOMADE";
-    case eolsym: return "end of line";
-	case idsym: return "identifier";
-    default: return "unknown";  // should not happen
+		case errorsym: return "error";
+		case lbracksym: return "(";
+		case rbracksym: return ")";
+		case commasym: return ",";
+		case opsym: return "operator";
+		case constsym: return "constant";
+		case sumsym: return "SUM";
+		case ifsym: return "IF";
+		case whocodedsym: return "WHOMADE";
+		case eolsym: return "end of line";
+		case idsym: return "identifier";
+		default: return "unknown";  // should not happen
 	}
 }
 
@@ -391,19 +391,19 @@ int CParser::Priority(int optorkind) {
 	// returns the priority of an operator
 	// higher number means higher priority
 	switch(optorkind) {
-	case OPor: return 1;
-	case OPand: return 2;
-	case OPgreater:
-	case OPless:
-	case OPgreaterequal:
-	case OPlessequal:
-	case OPequal:
-	case OPunequal: return 3;
-    case OPplus:
-    case OPminus: return 4;
-	case OPmodulus:
-    case OPtimes:
-    case OPdivide: return 5;
+		case OPor: return 1;
+		case OPand: return 2;
+		case OPgreater:
+		case OPless:
+		case OPgreaterequal:
+		case OPlessequal:
+		case OPequal:
+		case OPunequal: return 3;
+		case OPplus:
+		case OPminus: return 4;
+		case OPmodulus:
+		case OPtimes:
+		case OPdivide: return 5;
 	}
 	MT_assert(false);
 	return 0;      // should not happen
diff --git a/source/gameengine/Expressions/PyObjectPlus.cpp b/source/gameengine/Expressions/PyObjectPlus.cpp
index 10906cdae02..92be769ed71 100644
--- a/source/gameengine/Expressions/PyObjectPlus.cpp
+++ b/source/gameengine/Expressions/PyObjectPlus.cpp
@@ -1147,7 +1147,7 @@ PyObject *PyObjectPlus::NewProxyPlus_Ext(PyObjectPlus *self, PyTypeObject *tp, v
 		BGE_PROXY_REF(proxy) = NULL; 
 		BGE_PROXY_PTR(proxy) = ptr;
 #ifdef USE_WEAKREFS
-		BGE_PROXY_WKREF(self->m_proxy) = NULL;
+		BGE_PROXY_WKREF(proxy) = NULL;
 #endif
 		return proxy;
 	}
@@ -1184,46 +1184,10 @@ void PyObjectPlus::SetDeprecationWarnings(bool ignoreDeprecationWarnings)
 	m_ignore_deprecation_warnings = ignoreDeprecationWarnings;
 }
 
-void PyDebugLine()
-{
-	// import sys; print '\t%s:%d' % (sys._getframe(0).f_code.co_filename, sys._getframe(0).f_lineno)
-
-	PyObject *getframe, *frame;
-	PyObject *f_lineno, *f_code, *co_filename;
-
-	getframe = PySys_GetObject((char *)"_getframe"); // borrowed
-	if (getframe) {
-		frame = PyObject_CallObject(getframe, NULL);
-		if (frame) {
-			f_lineno= PyObject_GetAttrString(frame, "f_lineno");
-			f_code= PyObject_GetAttrString(frame, "f_code");
-			if (f_lineno && f_code) {
-				co_filename= ((PyCodeObject *)f_code)->co_filename; /* borrow */
-				if (co_filename) {
-
-					printf("\t%s:%d\n", _PyUnicode_AsString(co_filename), (int)PyLong_AsSsize_t(f_lineno));
-
-					Py_DECREF(f_lineno);
-					Py_DECREF(f_code);
-					Py_DECREF(frame);
-					return;
-				}
-			}
-			
-			Py_XDECREF(f_lineno);
-			Py_XDECREF(f_code);
-			Py_DECREF(frame);
-		}
-
-	}
-	PyErr_Clear();
-	printf("\tERROR - Could not access sys._getframe(0).f_lineno or sys._getframe().f_code.co_filename\n");
-}
-
 void PyObjectPlus::ShowDeprecationWarning_func(const char* old_way,const char* new_way)
 {
 	printf("Method %s is deprecated, please use %s instead.\n", old_way, new_way);
-	PyDebugLine();
+	PyC_LineSpit();
 }
 
 void PyObjectPlus::ClearDeprecationWarning()
diff --git a/source/gameengine/Expressions/PyObjectPlus.h b/source/gameengine/Expressions/PyObjectPlus.h
index 157124ebc81..080e7196d5a 100644
--- a/source/gameengine/Expressions/PyObjectPlus.h
+++ b/source/gameengine/Expressions/PyObjectPlus.h
@@ -54,7 +54,8 @@
 #ifdef WITH_PYTHON
 #ifdef USE_MATHUTILS
 extern "C" {
-#include "../../blender/python/generic/mathutils.h" /* so we can have mathutils callbacks */
+#include "../../blender/python/mathutils/mathutils.h" /* so we can have mathutils callbacks */
+#include "../../blender/python/generic/py_capi_utils.h" /* for PyC_LineSpit only */
 }
 #endif
 
@@ -254,12 +255,15 @@ typedef struct PyObjectPlus_Proxy {
 #define KX_PYMETHODTABLE_NOARGS(class_name, method_name) \
 	{#method_name , (PyCFunction) class_name::sPy##method_name, METH_NOARGS, (const char *)class_name::method_name##_doc}
 
+#define KX_PYMETHODTABLE_KEYWORDS(class_name, method_name) \
+	{#method_name , (PyCFunction) class_name::sPy##method_name, METH_VARARGS|METH_KEYWORDS, (const char *)class_name::method_name##_doc}
+
 /**
  * Function implementation macro
  */
 #define KX_PYMETHODDEF_DOC(class_name, method_name, doc_string) \
 const char class_name::method_name##_doc[] = doc_string; \
-PyObject* class_name::Py##method_name(PyObject* args, PyObject*)
+PyObject* class_name::Py##method_name(PyObject* args, PyObject* kwds)
 
 #define KX_PYMETHODDEF_DOC_VARARGS(class_name, method_name, doc_string) \
 const char class_name::method_name##_doc[] = doc_string; \
diff --git a/source/gameengine/GameLogic/CMakeLists.txt b/source/gameengine/GameLogic/CMakeLists.txt
index b6721650bad..bd417165337 100644
--- a/source/gameengine/GameLogic/CMakeLists.txt
+++ b/source/gameengine/GameLogic/CMakeLists.txt
@@ -25,13 +25,13 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	. 
-	../../../intern/string
+	.
+	../Expressions
+	../Rasterizer
+	../SceneGraph
 	../../../intern/container
-	../../../source/gameengine/Expressions 
-	../../../source/gameengine/SceneGraph
 	../../../intern/moto/include
-	../../../source/gameengine/Rasterizer
+	../../../intern/string
 )
 
 set(INC_SYS
@@ -39,8 +39,6 @@ set(INC_SYS
 )
 
 set(SRC
-	Joystick/SCA_Joystick.cpp
-	Joystick/SCA_JoystickEvents.cpp
 	SCA_2DFilterActuator.cpp
 	SCA_ANDController.cpp
 	SCA_ActuatorEventManager.cpp
@@ -81,10 +79,9 @@ set(SRC
 	SCA_TimeEventManager.cpp
 	SCA_XNORController.cpp
 	SCA_XORController.cpp
+	Joystick/SCA_Joystick.cpp
+	Joystick/SCA_JoystickEvents.cpp
 
-	Joystick/SCA_Joystick.h
-	Joystick/SCA_JoystickDefines.h
-	Joystick/SCA_JoystickPrivate.h
 	SCA_2DFilterActuator.h
 	SCA_ANDController.h
 	SCA_ActuatorEventManager.h
@@ -125,10 +122,15 @@ set(SRC
 	SCA_TimeEventManager.h
 	SCA_XNORController.h
 	SCA_XORController.h
+	Joystick/SCA_Joystick.h
+	Joystick/SCA_JoystickDefines.h
+	Joystick/SCA_JoystickPrivate.h
 )
 
 if(WITH_SDL)
-	list(APPEND INC_SYS ${SDL_INCLUDE_DIR})
+	list(APPEND INC_SYS
+		${SDL_INCLUDE_DIR}
+	)
 else()
 	add_definitions(-DDISABLE_SDL)
 endif()
diff --git a/source/gameengine/GameLogic/Joystick/SCA_Joystick.cpp b/source/gameengine/GameLogic/Joystick/SCA_Joystick.cpp
index a73a6d4631b..48ba09e67d2 100644
--- a/source/gameengine/GameLogic/Joystick/SCA_Joystick.cpp
+++ b/source/gameengine/GameLogic/Joystick/SCA_Joystick.cpp
@@ -89,7 +89,7 @@ SCA_Joystick *SCA_Joystick::GetInstance( short int joyindex )
 	{
 		int i;
 		// do this once only
-		if(SDL_InitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO ) == -1 ){
+		if(SDL_InitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO) == -1 ){
 			echo("Error-Initializing-SDL: " << SDL_GetError());
 			return NULL;
 		}
@@ -124,7 +124,7 @@ void SCA_Joystick::ReleaseInstance()
 			m_instance[i]= NULL;
 		}
 
-		SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO );
+		SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO);
 #endif
 	}
 }
diff --git a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
index 0a65fc1584a..7c1824cd4eb 100644
--- a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
@@ -40,34 +40,34 @@ SCA_2DFilterActuator::~SCA_2DFilterActuator()
 }
 
 SCA_2DFilterActuator::SCA_2DFilterActuator(
-        SCA_IObject *gameobj, 
+        SCA_IObject *gameobj,
         RAS_2DFilterManager::RAS_2DFILTER_MODE type,
-		short flag,
-		float float_arg,
-		int int_arg,
-		RAS_IRasterizer* rasterizer,
-		SCA_IScene* scene)
+        short flag,
+        float float_arg,
+        int int_arg,
+        RAS_IRasterizer* rasterizer,
+        SCA_IScene* scene)
     : SCA_IActuator(gameobj, KX_ACT_2DFILTER),
-     m_type(type),
-	 m_disableMotionBlur(flag),
-	 m_float_arg(float_arg),
-	 m_int_arg(int_arg),
-	 m_rasterizer(rasterizer),
-	 m_scene(scene)
+      m_type(type),
+      m_disableMotionBlur(flag),
+      m_float_arg(float_arg),
+      m_int_arg(int_arg),
+      m_rasterizer(rasterizer),
+      m_scene(scene)
 {
-	m_gameObj = NULL;
+	m_gameobj = NULL;
 	if(gameobj){
 		m_propNames = gameobj->GetPropertyNames();
-		m_gameObj = gameobj;
+		m_gameobj = gameobj;
 	}
 }
 
 
 CValue* SCA_2DFilterActuator::GetReplica()
 {
-    SCA_2DFilterActuator* replica = new SCA_2DFilterActuator(*this);
-    replica->ProcessReplica();
-    return replica;
+	SCA_2DFilterActuator* replica = new SCA_2DFilterActuator(*this);
+	replica->ProcessReplica();
+	return replica;
 }
 
 
@@ -91,10 +91,10 @@ bool SCA_2DFilterActuator::Update()
 	}
 	else if(m_type < RAS_2DFilterManager::RAS_2DFILTER_NUMBER_OF_FILTERS)
 	{
-		m_scene->Update2DFilter(m_propNames, m_gameObj, m_type, m_int_arg, m_shaderText);
+		m_scene->Update2DFilter(m_propNames, m_gameobj, m_type, m_int_arg, m_shaderText);
 	}
 	// once the filter is in place, no need to update it again => disable the actuator
-    return false;
+	return false;
 }
 
 
diff --git a/source/gameengine/GameLogic/SCA_2DFilterActuator.h b/source/gameengine/GameLogic/SCA_2DFilterActuator.h
index 87d2e8ddbcf..82c82ac3be5 100644
--- a/source/gameengine/GameLogic/SCA_2DFilterActuator.h
+++ b/source/gameengine/GameLogic/SCA_2DFilterActuator.h
@@ -42,7 +42,6 @@ class SCA_2DFilterActuator : public SCA_IActuator
 
 private:
 	vector<STR_String> m_propNames;
-	void * m_gameObj;
 	RAS_2DFilterManager::RAS_2DFILTER_MODE m_type;
 	short m_disableMotionBlur;
 	float m_float_arg;
@@ -53,19 +52,19 @@ private:
 
 public:
 
-    SCA_2DFilterActuator(
-        class SCA_IObject* gameobj,
-        RAS_2DFilterManager::RAS_2DFILTER_MODE type,
-		short flag,
-		float float_arg,
-		int int_arg,
-		RAS_IRasterizer* rasterizer,
-		SCA_IScene* scene);
+	SCA_2DFilterActuator(
+	        class SCA_IObject* gameobj,
+	        RAS_2DFilterManager::RAS_2DFILTER_MODE type,
+	        short flag,
+	        float float_arg,
+	        int int_arg,
+	        RAS_IRasterizer* rasterizer,
+	        SCA_IScene* scene);
 
 	void	SetShaderText(const char *text);
-    virtual ~SCA_2DFilterActuator();
-    virtual bool Update();
+	virtual ~SCA_2DFilterActuator();
+	virtual bool Update();
 
-    virtual CValue* GetReplica();
+	virtual CValue* GetReplica();
 };
 #endif
diff --git a/source/gameengine/GameLogic/SCA_ISensor.cpp b/source/gameengine/GameLogic/SCA_ISensor.cpp
index 0d09e33a81b..85982bd3c0f 100644
--- a/source/gameengine/GameLogic/SCA_ISensor.cpp
+++ b/source/gameengine/GameLogic/SCA_ISensor.cpp
@@ -216,8 +216,8 @@ void SCA_ISensor::UnregisterToManager()
 
 void SCA_ISensor::ActivateControllers(class SCA_LogicManager* logicmgr)
 {
-    for(vector<SCA_IController*>::const_iterator c= m_linkedcontrollers.begin();
-		c!=m_linkedcontrollers.end();++c)
+	for(vector<SCA_IController*>::const_iterator c= m_linkedcontrollers.begin();
+	    c!=m_linkedcontrollers.end();++c)
 	{
 		SCA_IController* contr = *c;
 		if (contr->IsActive())
diff --git a/source/gameengine/GameLogic/SCA_ISensor.h b/source/gameengine/GameLogic/SCA_ISensor.h
index 741448b1096..f90f1e19a67 100644
--- a/source/gameengine/GameLogic/SCA_ISensor.h
+++ b/source/gameengine/GameLogic/SCA_ISensor.h
@@ -105,7 +105,7 @@ public:
 	};
 
 	SCA_ISensor(SCA_IObject* gameobj,
-				class SCA_EventManager* eventmgr);;
+				class SCA_EventManager* eventmgr);
 	~SCA_ISensor();
 	virtual void	ReParent(SCA_IObject* parent);
 
diff --git a/source/gameengine/GameLogic/SCA_KeyboardSensor.cpp b/source/gameengine/GameLogic/SCA_KeyboardSensor.cpp
index 513be43ec28..a2374ccb9da 100644
--- a/source/gameengine/GameLogic/SCA_KeyboardSensor.cpp
+++ b/source/gameengine/GameLogic/SCA_KeyboardSensor.cpp
@@ -132,7 +132,7 @@ bool SCA_KeyboardSensor::Evaluate()
 	//  	cerr << "SCA_KeyboardSensor::Eval event, sensing for "<< m_hotkey << " at device " << inputdev << "\n";
 
 	/* See if we need to do logging: togPropState exists and is
-     * different from 0 */
+	 * different from 0 */
 	CValue* myparent = GetParent();
 	CValue* togPropState = myparent->GetProperty(m_toggleprop);
 	if (togPropState &&
@@ -400,7 +400,7 @@ void SCA_KeyboardSensor::LogKeystrokes(void)
 		
 		int index = 0;
 		/* Check on all keys whether they were pushed. This does not
-         * untangle the ordering, so don't type too fast :) */
+		 * untangle the ordering, so don't type too fast :) */
 		for (int i=SCA_IInputDevice::KX_BEGINKEY ; i<= SCA_IInputDevice::KX_ENDKEY;i++)
 		{
 			const SCA_InputEvent & inevent = inputdev->GetEventValue((SCA_IInputDevice::KX_EnumInputs) i);
diff --git a/source/gameengine/GameLogic/SCA_MouseSensor.cpp b/source/gameengine/GameLogic/SCA_MouseSensor.cpp
index a1836163e9c..93d2ae2c1c5 100644
--- a/source/gameengine/GameLogic/SCA_MouseSensor.cpp
+++ b/source/gameengine/GameLogic/SCA_MouseSensor.cpp
@@ -50,12 +50,12 @@
 /* ------------------------------------------------------------------------- */
 
 SCA_MouseSensor::SCA_MouseSensor(SCA_MouseManager* eventmgr, 
-								 int startx,int starty,
-								 short int mousemode,
-								 SCA_IObject* gameobj)
+                                 int startx,int starty,
+                                 short int mousemode,
+                                 SCA_IObject* gameobj)
     : SCA_ISensor(gameobj,eventmgr),
-	m_x(startx),
-	m_y(starty)
+      m_x(startx),
+      m_y(starty)
 {
 	m_mousemode   = mousemode;
 	m_triggermode = true;
@@ -72,7 +72,7 @@ void SCA_MouseSensor::Init()
 
 SCA_MouseSensor::~SCA_MouseSensor() 
 {
-    /* Nothing to be done here. */
+	/* Nothing to be done here. */
 }
 
 void SCA_MouseSensor::UpdateHotkey(void *self)
diff --git a/source/gameengine/GameLogic/SCA_PythonController.h b/source/gameengine/GameLogic/SCA_PythonController.h
index 3ccbfea7ed5..739e566237b 100644
--- a/source/gameengine/GameLogic/SCA_PythonController.h
+++ b/source/gameengine/GameLogic/SCA_PythonController.h
@@ -34,7 +34,7 @@
 
 #ifndef KX_PYTHONCONTROLLER_H
 #define KX_PYTHONCONTROLLER_H
-	      
+
 #include "SCA_IController.h"
 #include "SCA_LogicManager.h"
 #include "BoolValue.h"
diff --git a/source/gameengine/GameLogic/SCA_RandomActuator.cpp b/source/gameengine/GameLogic/SCA_RandomActuator.cpp
index 3a6b00198e1..c9d11a27c76 100644
--- a/source/gameengine/GameLogic/SCA_RandomActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_RandomActuator.cpp
@@ -152,7 +152,7 @@ bool SCA_RandomActuator::Update()
 		/* If x_1, x_2, ... is a sequence of random numbers with uniform     */
 		/* distribution between zero and one, k is the first integer for     */
 		/* which the product x_1*x_2*...*x_k < exp(-\lamba).                 */
-		float a = 0.0, b = 0.0;
+		float a, b;
 		int res = 0;
 		/* The - sign is important here! The number to test for, a, must be  */
 		/* between 0 and 1.                                                  */
@@ -207,10 +207,10 @@ bool SCA_RandomActuator::Update()
 			  sensible values. The termination condition states two 
 			  things: 
 			  1. s >= 0 is not allowed: to prevent the distro from 
-			     getting a bias towards high values. This is a small 
+				 getting a bias towards high values. This is a small
 				 correction, really, and might also be left out.
 			  2. s == 0 is not allowed: to prevent a division by zero
-			     when renormalising the drawn value to the desired 
+				 when renormalising the drawn value to the desired
 				 distribution shape. As a side effect, the distro will
 				 never yield the exact mean. 
 			  I am not sure whether this is consistent, since the error 
diff --git a/source/gameengine/GameLogic/SCA_RandomNumberGenerator.cpp b/source/gameengine/GameLogic/SCA_RandomNumberGenerator.cpp
index 06c24c8211b..67af6237a8d 100644
--- a/source/gameengine/GameLogic/SCA_RandomNumberGenerator.cpp
+++ b/source/gameengine/GameLogic/SCA_RandomNumberGenerator.cpp
@@ -68,12 +68,12 @@ SCA_RandomNumberGenerator::~SCA_RandomNumberGenerator() {
 
 void SCA_RandomNumberGenerator::SetStartVector(void) {
 	/* setting initial seeds to mt[N] using         */
-    /* the generator Line 25 of Table 1 in          */
-    /* [KNUTH 1981, The Art of Computer Programming */
-    /*    Vol. 2 (2nd Ed.), pp102]                  */
-    mt[0] = m_seed & 0xffffffff;
-    for (mti = 1; mti < N; mti++)
-        mt[mti] = (69069 * mt[mti-1]) & 0xffffffff;
+	/* the generator Line 25 of Table 1 in          */
+	/* [KNUTH 1981, The Art of Computer Programming */
+	/*    Vol. 2 (2nd Ed.), pp102]                  */
+	mt[0] = m_seed & 0xffffffff;
+	for (mti = 1; mti < N; mti++)
+		mt[mti] = (69069 * mt[mti-1]) & 0xffffffff;
 }
 
 long SCA_RandomNumberGenerator::GetSeed() { return m_seed; }
@@ -87,39 +87,39 @@ void SCA_RandomNumberGenerator::SetSeed(long newseed)
  * This is the important part: copied verbatim :)
  */
 unsigned long SCA_RandomNumberGenerator::Draw() {
-    static unsigned long mag01[2] = { 0x0, MATRIX_A };
-    /* mag01[x] = x * MATRIX_A  for x=0,1 */
-
-    unsigned long y;
-
-    if (mti >= N) { /* generate N words at one time */
-        int kk;
-
-        /* I set this in the constructor, so it is always satisfied ! */
-//          if (mti == N+1)   /* if sgenrand() has not been called, */
-//              GEN_srand(4357); /* a default initial seed is used   */
-        
-        for (kk = 0; kk < N - M; kk++) {
-            y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
-            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
-        }
-        for (; kk < N-1; kk++) {
-            y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
-            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
-        }
-        y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
-        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
-
-        mti = 0;
-    }
-  
-    y = mt[mti++];
-    y ^= TEMPERING_SHIFT_U(y);
-    y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
-    y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
-    y ^= TEMPERING_SHIFT_L(y);
-
-    return y;
+	static unsigned long mag01[2] = { 0x0, MATRIX_A };
+	/* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+	unsigned long y;
+
+	if (mti >= N) { /* generate N words at one time */
+		int kk;
+
+		/* I set this in the constructor, so it is always satisfied ! */
+		//          if (mti == N+1)   /* if sgenrand() has not been called, */
+		//              GEN_srand(4357); /* a default initial seed is used   */
+
+		for (kk = 0; kk < N - M; kk++) {
+			y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
+			mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
+		}
+		for (; kk < N-1; kk++) {
+			y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
+			mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
+		}
+		y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
+		mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
+
+		mti = 0;
+	}
+
+	y = mt[mti++];
+	y ^= TEMPERING_SHIFT_U(y);
+	y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
+	y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
+	y ^= TEMPERING_SHIFT_L(y);
+
+	return y;
 }
 
 float SCA_RandomNumberGenerator::DrawFloat() {
diff --git a/source/gameengine/GameLogic/SCA_RandomSensor.cpp b/source/gameengine/GameLogic/SCA_RandomSensor.cpp
index 99e25042582..c23722d2d3c 100644
--- a/source/gameengine/GameLogic/SCA_RandomSensor.cpp
+++ b/source/gameengine/GameLogic/SCA_RandomSensor.cpp
@@ -48,8 +48,8 @@
 /* ------------------------------------------------------------------------- */
 
 SCA_RandomSensor::SCA_RandomSensor(SCA_EventManager* eventmgr, 
-				 SCA_IObject* gameobj, 
-				 int startseed)
+                                   SCA_IObject* gameobj,
+                                   int startseed)
     : SCA_ISensor(gameobj,eventmgr)
 {
 	m_basegenerator = new SCA_RandomNumberGenerator(startseed);
@@ -65,10 +65,10 @@ SCA_RandomSensor::~SCA_RandomSensor()
 
 void SCA_RandomSensor::Init()
 {
-    m_iteration  = 0;
+	m_iteration  = 0;
 	m_interval = 0;
 	m_lastdraw   = false;
-    m_currentDraw = m_basegenerator->Draw();
+	m_currentDraw = m_basegenerator->Draw();
 }
 
 
@@ -97,19 +97,19 @@ bool SCA_RandomSensor::IsPositiveTrigger()
 
 bool SCA_RandomSensor::Evaluate()
 {
-    /* Random generator is the generator from Line 25 of Table 1 in          */
-    /* [KNUTH 1981, The Art of Computer Programming Vol. 2                   */
-    /* (2nd Ed.), pp102]                                                     */
-    /* It's a very simple max. length sequence generator. We can             */
-    /* draw 32 bool values before having to generate the next                */
-    /* sequence value. There are some theorems that will tell you            */
-    /* this is a reasonable way of generating bools. Check Knuth.            */
-    /* Furthermore, we only draw each <delay>-eth frame.                     */
+	/* Random generator is the generator from Line 25 of Table 1 in          */
+	/* [KNUTH 1981, The Art of Computer Programming Vol. 2                   */
+	/* (2nd Ed.), pp102]                                                     */
+	/* It's a very simple max. length sequence generator. We can             */
+	/* draw 32 bool values before having to generate the next                */
+	/* sequence value. There are some theorems that will tell you            */
+	/* this is a reasonable way of generating bools. Check Knuth.            */
+	/* Furthermore, we only draw each <delay>-eth frame.                     */
 
 	bool evaluateResult = false;
 
 	if (++m_interval > m_pulse_frequency) {
-	    bool drawResult = false;
+		bool drawResult = false;
 		m_interval = 0;
 		if (m_iteration > 31) {
 			m_currentDraw = m_basegenerator->Draw();
@@ -122,8 +122,8 @@ bool SCA_RandomSensor::Evaluate()
 		evaluateResult = drawResult != m_lastdraw;
 		m_lastdraw = drawResult;
 	}
-    
-    /* now pass this result to some controller */
+
+	/* now pass this result to some controller */
 	return evaluateResult;
 }
 
diff --git a/source/gameengine/GameLogic/SCA_XORController.cpp b/source/gameengine/GameLogic/SCA_XORController.cpp
index f5eefd5cc08..4a03062b6ad 100644
--- a/source/gameengine/GameLogic/SCA_XORController.cpp
+++ b/source/gameengine/GameLogic/SCA_XORController.cpp
@@ -63,22 +63,22 @@ void SCA_XORController::Trigger(SCA_LogicManager* logicmgr)
 	bool sensorresult = false;
 
 	for (vector<SCA_ISensor*>::const_iterator is=m_linkedsensors.begin();
-	!(is==m_linkedsensors.end());is++)
+	     !(is==m_linkedsensors.end());is++)
 	{
 		SCA_ISensor* sensor = *is;
 		if (sensor->GetState())
 		{
 			if (sensorresult == true)
 			{
-                sensorresult = false;
+				sensorresult = false;
 				break;
 			}
-            sensorresult = true;
+			sensorresult = true;
 		}
 	}
 	
 	for (vector<SCA_IActuator*>::const_iterator i=m_linkedactuators.begin();
-	!(i==m_linkedactuators.end());i++)
+	     !(i==m_linkedactuators.end());i++)
 	{
 		SCA_IActuator* actua = *i;
 		logicmgr->AddActiveActuator(actua,sensorresult);
diff --git a/source/gameengine/GamePlayer/common/CMakeLists.txt b/source/gameengine/GamePlayer/common/CMakeLists.txt
index d16ec6a2f22..8c5897fa48e 100644
--- a/source/gameengine/GamePlayer/common/CMakeLists.txt
+++ b/source/gameengine/GamePlayer/common/CMakeLists.txt
@@ -26,31 +26,31 @@
 
 set(INC
 	.
-	../../../../intern/string
+	../ghost
+	../../BlenderRoutines
+	../../Converter
+	../../Expressions
+	../../GameLogic
+	../../Ketsji
+	../../Network
+	../../Network/LoopBackNetwork
+	../../Physics/common
+	../../Rasterizer
+	../../Rasterizer/RAS_OpenGLRasterizer
+	../../SceneGraph
+	../../../blender
+	../../../blender/blenfont
+	../../../blender/blenkernel
+	../../../blender/blenlib
+	../../../blender/blenloader
+	../../../blender/gpu
+	../../../blender/imbuf
+	../../../blender/makesdna
+	../../../../intern/container
 	../../../../intern/ghost
 	../../../../intern/guardedalloc
-	../../../../intern/container
 	../../../../intern/moto/include
-	../../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer
-	../../../../source/gameengine/Converter
-	../../../../source/gameengine/BlenderRoutines
-	../../../../source/blender/imbuf
-	../../../../source/gameengine/Ketsji
-	../../../../source/blender/blenlib
-	../../../../source/blender/blenfont
-	../../../../source/blender/blenkernel
-	../../../../source/blender
-	../../../../source/blender/makesdna
-	../../../../source/gameengine/Rasterizer
-	../../../../source/gameengine/GameLogic
-	../../../../source/gameengine/Expressions
-	../../../../source/gameengine/Network
-	../../../../source/gameengine/SceneGraph
-	../../../../source/gameengine/Physics/common
-	../../../../source/gameengine/Network/LoopBackNetwork
-	../../../../source/gameengine/GamePlayer/ghost
-	../../../../source/blender/blenloader
-	../../../../source/blender/gpu
+	../../../../intern/string
 )
 
 set(INC_SYS
@@ -61,7 +61,6 @@ set(INC_SYS
 )
 
 set(SRC 
-	bmfont.cpp
 	GPC_Canvas.cpp
 	GPC_Engine.cpp
 	GPC_KeyboardDevice.cpp
@@ -71,6 +70,7 @@ set(SRC
 	GPC_RawLogoArrays.cpp
 	GPC_RenderTools.cpp
 	GPC_System.cpp
+	bmfont.cpp
 
 	GPC_Canvas.h
 	GPC_Engine.h
diff --git a/source/gameengine/GamePlayer/common/bmfont.cpp b/source/gameengine/GamePlayer/common/bmfont.cpp
index e3b900173d9..ecb2c4f3bd1 100644
--- a/source/gameengine/GamePlayer/common/bmfont.cpp
+++ b/source/gameengine/GamePlayer/common/bmfont.cpp
@@ -190,7 +190,7 @@ void detectBitmapFont(ImBuf *ibuf)
 	long i;
 	
 	if (ibuf != NULL) {
-	        // bitmap must have an x size that is a power of two
+		// bitmap must have an x size that is a power of two
 		if (is_power_of_two(ibuf->x)) {
 			rect = (unsigned char *) (ibuf->rect + (ibuf->x * (ibuf->y - 1)));
 			// printf ("starts with: %s %c %c %c %c\n", rect, rect[0], rect[1], rect[2], rect[3]);
diff --git a/source/gameengine/GamePlayer/ghost/CMakeLists.txt b/source/gameengine/GamePlayer/ghost/CMakeLists.txt
index 5ac121099c3..944ec9abd67 100644
--- a/source/gameengine/GamePlayer/ghost/CMakeLists.txt
+++ b/source/gameengine/GamePlayer/ghost/CMakeLists.txt
@@ -26,32 +26,32 @@
 
 set(INC
 	.
-	../../../../intern/string
+	../common
+	../../BlenderRoutines
+	../../Converter
+	../../Expressions
+	../../GameLogic
+	../../Ketsji
+	../../Network
+	../../Network/LoopBackNetwork
+	../../Physics/common
+	../../Rasterizer
+	../../Rasterizer/RAS_OpenGLRasterizer
+	../../SceneGraph
+	../../../blender
+	../../../blender/blenfont
+	../../../blender/blenkernel
+	../../../blender/blenlib
+	../../../blender/blenloader
+	../../../blender/gpu
+	../../../blender/imbuf
+	../../../blender/makesdna
+	../../../blender/makesrna
+	../../../../intern/container
 	../../../../intern/ghost
 	../../../../intern/guardedalloc
-	../../../../intern/container
 	../../../../intern/moto/include
-	../../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer
-	../../../../source/gameengine/BlenderRoutines
-	../../../../source/gameengine/Converter
-	../../../../source/blender/imbuf
-	../../../../source/gameengine/Ketsji
-	../../../../source/blender/blenfont
-	../../../../source/blender/blenlib
-	../../../../source/blender/blenkernel
-	../../../../source/blender
-	../../../../source/blender/makesdna
-	../../../../source/blender/makesrna
-	../../../../source/gameengine/Rasterizer
-	../../../../source/gameengine/GameLogic
-	../../../../source/gameengine/Expressions
-	../../../../source/gameengine/Network
-	../../../../source/gameengine/SceneGraph
-	../../../../source/gameengine/Physics/common
-	../../../../source/gameengine/Network/LoopBackNetwork
-	../../../../source/gameengine/GamePlayer/common
-	../../../../source/blender/blenloader
-	../../../../source/blender/gpu
+	../../../../intern/string
 )
 
 set(INC_SYS
@@ -62,9 +62,9 @@ set(INC_SYS
 set(SRC 
 	GPG_Application.cpp
 	GPG_Canvas.cpp
-	GPG_ghost.cpp
 	GPG_KeyboardDevice.cpp
 	GPG_System.cpp
+	GPG_ghost.cpp
 
 	GPG_Application.h
 	GPG_Canvas.h
diff --git a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
index 6487d0298c7..5bc6093a9ff 100644
--- a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
+++ b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
@@ -139,7 +139,7 @@ GPG_Application::GPG_Application(GHOST_ISystem* system)
 
 GPG_Application::~GPG_Application(void)
 {
-    if(m_pyGlobalDictString) {
+	if(m_pyGlobalDictString) {
 		delete [] m_pyGlobalDictString;
 		m_pyGlobalDictString = 0;
 		m_pyGlobalDictString_Length = 0;
@@ -192,7 +192,7 @@ static LRESULT CALLBACK screenSaverWindowProc(HWND hwnd, UINT uMsg, WPARAM wPara
 			LONG dx = scr_save_mouse_pos.x - pt.x;
 			LONG dy = scr_save_mouse_pos.y - pt.y;
 			if (abs(dx) > SCR_SAVE_MOUSE_MOVE_THRESHOLD
-			    || abs(dy) > SCR_SAVE_MOUSE_MOVE_THRESHOLD)
+			        || abs(dy) > SCR_SAVE_MOUSE_MOVE_THRESHOLD)
 			{
 				close = TRUE;
 			}
@@ -448,6 +448,7 @@ bool GPG_Application::processEvent(GHOST_IEvent* event)
 
 
 		case GHOST_kEventWindowClose:
+		case GHOST_kEventQuit:
 			m_exitRequested = KX_EXIT_REQUEST_OUTSIDE;
 			break;
 
@@ -544,6 +545,7 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
 		bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
 		bool useLists = (SYS_GetCommandLineInt(syshandle, "displaylists", gm->flag & GAME_DISPLAY_LISTS) != 0);
 		bool nodepwarnings = (SYS_GetCommandLineInt(syshandle, "ignore_deprecation_warnings", 1) != 0);
+		bool restrictAnimFPS = gm->flag & GAME_RESTRICT_ANIM_UPDATES;
 
 		if(GLEW_ARB_multitexture && GLEW_VERSION_1_1)
 			m_blendermat = (SYS_GetCommandLineInt(syshandle, "blender_material", 1) != 0);
@@ -615,7 +617,6 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
 		m_ketsjiengine->SetCanvas(m_canvas);
 		m_ketsjiengine->SetRenderTools(m_rendertools);
 		m_ketsjiengine->SetRasterizer(m_rasterizer);
-		m_ketsjiengine->SetNetworkDevice(m_networkdevice);
 
 		m_ketsjiengine->SetTimingDisplay(frameRate, false, false);
 #ifdef WITH_PYTHON
@@ -626,6 +627,7 @@ bool GPG_Application::initEngine(GHOST_IWindow* window, const int stereoMode)
 
 		m_ketsjiengine->SetUseFixedTime(fixed_framerate);
 		m_ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
+		m_ketsjiengine->SetRestrictAnimationFPS(restrictAnimFPS);
 
 		m_engineInitialized = true;
 	}
diff --git a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
index 121f38eef02..3f8bcf9e2ad 100644
--- a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
+++ b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
@@ -64,6 +64,7 @@ extern "C"
 #include "BKE_node.h"	
 #include "BKE_report.h"
 #include "BKE_library.h"
+#include "BLI_threads.h"
 #include "BLI_blenlib.h"
 #include "DNA_scene_types.h"
 #include "DNA_userdef_types.h"
@@ -379,12 +380,12 @@ int main(int argc, char** argv)
 #endif /* __linux__ */
 	BLI_where_am_i(bprogname, sizeof(bprogname), argv[0]);
 #ifdef __APPLE__
-    // Can't use Carbon right now because of double defined type ID (In Carbon.h and DNA_ID.h, sigh)
-    /*
-    IBNibRef 		nibRef;
-    WindowRef 		window;
-    OSStatus		err;
-	
+	// Can't use Carbon right now because of double defined type ID (In Carbon.h and DNA_ID.h, sigh)
+	/*
+	IBNibRef 		nibRef;
+	WindowRef 		window;
+	OSStatus		err;
+
 	  // Create a Nib reference passing the name of the nib file (without the .nib extension)
 	  // CreateNibReference only searches into the application bundle.
 	  err = ::CreateNibReference(CFSTR("main"), &nibRef);
@@ -397,9 +398,13 @@ int main(int argc, char** argv)
 		
 		  // We don't need the nib reference anymore.
 		  ::DisposeNibReference(nibRef);
-    */
+	*/
 #endif // __APPLE__
-
+	
+	// We don't use threads directly in the BGE, but we need to call this so things like
+	// freeing up GPU_Textures works correctly.
+	BLI_threadapi_init();
+	
 	RNA_init();
 
 	init_nodesystem();
@@ -408,6 +413,7 @@ int main(int argc, char** argv)
 
 	// We load our own G.main, so free the one that initglobals() gives us
 	free_main(G.main);
+	G.main = NULL;
 
 	IMB_init();
 
@@ -415,7 +421,7 @@ int main(int argc, char** argv)
 	BLF_init(11, U.dpi);
 	BLF_lang_init();
 	BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
- 
+
 	// Parse command line options
 #if defined(DEBUG)
 	printf("argv[0] = '%s'\n", argv[0]);
@@ -450,6 +456,9 @@ int main(int argc, char** argv)
 	U.audioformat = 0x24;
 	U.audiochannels = 2;
 
+	// XXX this one too
+	U.anisotropic_filter = 2;
+
 	sound_init_once();
 
 	/* if running blenderplayer the last argument can't be parsed since it has to be the filename. */
@@ -705,6 +714,8 @@ int main(int argc, char** argv)
 		{
 			GPU_set_mipmap(0);
 		}
+
+		GPU_set_anisotropic(U.anisotropic_filter);
 		
 		// Create the system
 		if (GHOST_ISystem::createSystem() == GHOST_kSuccess)
diff --git a/source/gameengine/GamePlayer/ghost/SConscript b/source/gameengine/GamePlayer/ghost/SConscript
index e3ffc1a406b..de063f5e297 100644
--- a/source/gameengine/GamePlayer/ghost/SConscript
+++ b/source/gameengine/GamePlayer/ghost/SConscript
@@ -40,6 +40,8 @@ incs = ['.',
         '#source/blender/gpu',
         '#extern/glew/include']
 
+incs.append(env['BF_PTHREADS_INC'])
+
 defs = [ 'GLEW_STATIC' ]
 
 if env['WITH_BF_PYTHON']:
diff --git a/source/gameengine/Ketsji/BL_Action.cpp b/source/gameengine/Ketsji/BL_Action.cpp
new file mode 100644
index 00000000000..08794042e37
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_Action.cpp
@@ -0,0 +1,453 @@
+/**
+ * $Id$
+ *
+ * ***** 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): Mitchell Stokes.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file BL_Action.cpp
+ *  \ingroup ketsji
+ */
+
+#include <cstdlib>
+
+#include "BL_Action.h"
+#include "BL_ArmatureObject.h"
+#include "BL_DeformableGameObject.h"
+#include "BL_ShapeDeformer.h"
+#include "KX_IpoConvert.h"
+#include "KX_GameObject.h"
+
+// These three are for getting the action from the logic manager
+#include "KX_Scene.h"
+#include "KX_PythonInit.h"
+#include "SCA_LogicManager.h"
+
+extern "C" {
+#include "BKE_animsys.h"
+#include "BKE_action.h"
+#include "RNA_access.h"
+#include "RNA_define.h"
+}
+
+BL_Action::BL_Action(class KX_GameObject* gameobj)
+:
+	m_action(NULL),
+	m_pose(NULL),
+	m_blendpose(NULL),
+	m_blendinpose(NULL),
+	m_ptrrna(NULL),
+	m_obj(gameobj),
+	m_startframe(0.f),
+	m_endframe(0.f),
+	m_endtime(0.f),
+	m_localtime(0.f),
+	m_blendin(0.f),
+	m_blendframe(0.f),
+	m_blendstart(0.f),
+	m_speed(0.f),
+	m_priority(0),
+	m_playmode(0),
+	m_ipo_flags(0),
+	m_done(true),
+	m_calc_localtime(true)
+{
+	if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+	{
+		BL_ArmatureObject *obj = (BL_ArmatureObject*)m_obj;
+
+		m_ptrrna = new PointerRNA();
+		RNA_id_pointer_create(&obj->GetArmatureObject()->id, m_ptrrna);
+	}
+	else
+	{
+		BL_DeformableGameObject *obj = (BL_DeformableGameObject*)m_obj;
+		BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
+
+		if (shape_deformer)
+		{
+			m_ptrrna = new PointerRNA();
+			RNA_id_pointer_create(&shape_deformer->GetKey()->id, m_ptrrna);
+		}
+	}
+}
+
+BL_Action::~BL_Action()
+{
+	if (m_pose)
+		game_free_pose(m_pose);
+	if (m_blendpose)
+		game_free_pose(m_blendpose);
+	if (m_blendinpose)
+		game_free_pose(m_blendinpose);
+	if (m_ptrrna)
+		delete m_ptrrna;
+	ClearControllerList();
+}
+
+void BL_Action::ClearControllerList()
+{
+	// Clear out the controller list
+	std::vector<SG_Controller*>::iterator it;
+	for (it = m_sg_contr_list.begin(); it != m_sg_contr_list.end(); it++)
+	{
+		m_obj->GetSGNode()->RemoveSGController((*it));
+		delete *it;
+	}
+
+	m_sg_contr_list.clear();
+}
+
+bool BL_Action::Play(const char* name,
+					float start,
+					float end,
+					short priority,
+					float blendin,
+					short play_mode,
+					float layer_weight,
+					short ipo_flags,
+					float playback_speed)
+{
+
+	// Only start playing a new action if we're done, or if
+	// the new action has a higher priority
+	if (priority != 0 && !IsDone() && priority >= m_priority)
+		return false;
+	m_priority = priority;
+	bAction* prev_action = m_action;
+
+	// First try to load the action
+	m_action = (bAction*)KX_GetActiveScene()->GetLogicManager()->GetActionByName(name);
+	if (!m_action)
+	{
+		printf("Failed to load action: %s\n", name);
+		m_done = true;
+		return false;
+	}
+
+	if (prev_action != m_action)
+	{
+		// First get rid of any old controllers
+		ClearControllerList();
+
+		// Create an SG_Controller
+		SG_Controller *sg_contr = BL_CreateIPO(m_action, m_obj, KX_GetActiveScene()->GetSceneConverter());
+		m_sg_contr_list.push_back(sg_contr);
+		m_obj->GetSGNode()->AddSGController(sg_contr);
+		sg_contr->SetObject(m_obj->GetSGNode());
+
+		// Extra controllers
+		if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_LIGHT)
+		{
+			sg_contr = BL_CreateLampIPO(m_action, m_obj, KX_GetActiveScene()->GetSceneConverter());
+			m_sg_contr_list.push_back(sg_contr);
+			m_obj->GetSGNode()->AddSGController(sg_contr);
+			sg_contr->SetObject(m_obj->GetSGNode());
+		}
+		else if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_CAMERA)
+		{
+			sg_contr = BL_CreateCameraIPO(m_action, m_obj, KX_GetActiveScene()->GetSceneConverter());
+			m_sg_contr_list.push_back(sg_contr);
+			m_obj->GetSGNode()->AddSGController(sg_contr);
+			sg_contr->SetObject(m_obj->GetSGNode());
+		}
+	}
+	
+	m_ipo_flags = ipo_flags;
+	InitIPO();
+
+	// Setup blendin shapes/poses
+	if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+	{
+		BL_ArmatureObject *obj = (BL_ArmatureObject*)m_obj;
+		obj->GetMRDPose(&m_blendinpose);
+	}
+	else
+	{
+		BL_DeformableGameObject *obj = (BL_DeformableGameObject*)m_obj;
+		BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
+		
+		if (shape_deformer && shape_deformer->GetKey())
+		{
+			obj->GetShape(m_blendinshape);
+
+			// Now that we have the previous blend shape saved, we can clear out the key to avoid any
+			// further interference.
+			KeyBlock *kb;
+			for (kb=(KeyBlock*)shape_deformer->GetKey()->block.first; kb; kb=(KeyBlock*)kb->next)
+				kb->curval = 0.f;
+		}
+	}
+
+	// Now that we have an action, we have something we can play
+	m_starttime = KX_GetActiveEngine()->GetFrameTime();
+	m_startframe = m_localtime = start;
+	m_endframe = end;
+	m_blendin = blendin;
+	m_playmode = play_mode;
+	m_endtime = 0.f;
+	m_blendframe = 0.f;
+	m_blendstart = 0.f;
+	m_speed = playback_speed;
+	m_layer_weight = layer_weight;
+	
+	m_done = false;
+
+	return true;
+}
+
+void BL_Action::Stop()
+{
+	m_done = true;
+}
+
+bool BL_Action::IsDone()
+{
+	return m_done;
+}
+
+void BL_Action::InitIPO()
+{
+	// Initialize the IPOs
+	std::vector<SG_Controller*>::iterator it;
+	for (it = m_sg_contr_list.begin(); it != m_sg_contr_list.end(); it++)
+	{
+		(*it)->SetOption(SG_Controller::SG_CONTR_IPO_RESET, true);
+		(*it)->SetOption(SG_Controller::SG_CONTR_IPO_IPO_AS_FORCE, m_ipo_flags & ACT_IPOFLAG_FORCE);
+		(*it)->SetOption(SG_Controller::SG_CONTR_IPO_IPO_ADD, m_ipo_flags & ACT_IPOFLAG_ADD);
+		(*it)->SetOption(SG_Controller::SG_CONTR_IPO_LOCAL, m_ipo_flags & ACT_IPOFLAG_LOCAL);
+	}
+}
+
+bAction *BL_Action::GetAction()
+{
+	return (IsDone()) ? NULL : m_action;
+}
+
+float BL_Action::GetFrame()
+{
+	return m_localtime;
+}
+
+void BL_Action::SetFrame(float frame)
+{
+	// Clamp the frame to the start and end frame
+	if (frame < min(m_startframe, m_endframe))
+		frame = min(m_startframe, m_endframe);
+	else if (frame > max(m_startframe, m_endframe))
+		frame = max(m_startframe, m_endframe);
+	
+	m_localtime = frame;
+	m_calc_localtime = false;
+}
+
+void BL_Action::SetPlayMode(short play_mode)
+{
+	m_playmode = play_mode;
+}
+
+void BL_Action::SetTimes(float start, float end)
+{
+	m_startframe = start;
+	m_endframe = end;
+}
+
+void BL_Action::SetLocalTime(float curtime)
+{
+	float dt = (curtime-m_starttime)*KX_KetsjiEngine::GetAnimFrameRate()*m_speed;
+
+	if (m_endframe < m_startframe)
+		dt = -dt;
+
+	m_localtime = m_startframe + dt;
+}
+
+void BL_Action::ResetStartTime(float curtime)
+{
+	float dt = m_localtime - m_startframe;
+
+	m_starttime = curtime - dt / (KX_KetsjiEngine::GetAnimFrameRate()*m_speed);
+	SetLocalTime(curtime);
+}
+
+void BL_Action::IncrementBlending(float curtime)
+{
+	// Setup m_blendstart if we need to
+	if (m_blendstart == 0.f)
+		m_blendstart = curtime;
+	
+	// Bump the blend frame
+	m_blendframe = (curtime - m_blendstart)*KX_KetsjiEngine::GetAnimFrameRate();
+
+	// Clamp
+	if (m_blendframe>m_blendin)
+		m_blendframe = m_blendin;
+}
+
+
+void BL_Action::BlendShape(Key* key, float srcweight, std::vector<float>& blendshape)
+{
+	vector<float>::const_iterator it;
+	float dstweight;
+	KeyBlock *kb;
+	
+	dstweight = 1.0F - srcweight;
+	//printf("Dst: %f\tSrc: %f\n", srcweight, dstweight);
+	for (it=blendshape.begin(), kb = (KeyBlock*)key->block.first; 
+		 kb && it != blendshape.end(); 
+		 kb = (KeyBlock*)kb->next, it++) {
+		//printf("OirgKeys: %f\t%f\n", kb->curval, (*it));
+		kb->curval = kb->curval * dstweight + (*it) * srcweight;
+		//printf("NewKey: %f\n", kb->curval);
+	}
+	//printf("\n");
+}
+
+void BL_Action::Update(float curtime)
+{
+	// Don't bother if we're done with the animation
+	if (m_done)
+		return;
+
+	curtime -= KX_KetsjiEngine::GetSuspendedDelta();
+
+	if (m_calc_localtime)
+		SetLocalTime(curtime);
+	else
+	{
+		ResetStartTime(curtime);
+		m_calc_localtime = true;
+	}
+
+	// Handle wrap around
+	if (m_localtime < min(m_startframe, m_endframe) || m_localtime > max(m_startframe, m_endframe))
+	{
+		switch(m_playmode)
+		{
+		case ACT_MODE_PLAY:
+			// Clamp
+			m_localtime = m_endframe;
+			m_done = true;
+			break;
+		case ACT_MODE_LOOP:
+			// Put the time back to the beginning
+			m_localtime = m_startframe;
+			m_starttime = curtime;
+			break;
+		case ACT_MODE_PING_PONG:
+			// Swap the start and end frames
+			float temp = m_startframe;
+			m_startframe = m_endframe;
+			m_endframe = temp;
+
+			m_starttime = curtime;
+
+			break;
+		}
+
+		if (!m_done)
+			InitIPO();
+	}
+
+	if (m_obj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+	{
+		BL_ArmatureObject *obj = (BL_ArmatureObject*)m_obj;
+		obj->GetPose(&m_pose);
+
+		// Extract the pose from the action
+		{
+			Object *arm = obj->GetArmatureObject();
+			bPose *temp = arm->pose;
+
+			arm->pose = m_pose;
+			animsys_evaluate_action(m_ptrrna, m_action, NULL, m_localtime);
+
+			arm->pose = temp;
+		}
+
+		// Handle blending between armature actions
+		if (m_blendin && m_blendframe<m_blendin)
+		{
+			IncrementBlending(curtime);
+
+			// Calculate weight
+			float weight = 1.f - (m_blendframe/m_blendin);
+
+			// Blend the poses
+			game_blend_poses(m_pose, m_blendinpose, weight);
+		}
+
+
+		// Handle layer blending
+		if (m_layer_weight >= 0)
+		{
+			obj->GetMRDPose(&m_blendpose);
+			game_blend_poses(m_pose, m_blendpose, m_layer_weight);
+		}
+
+		obj->SetPose(m_pose);
+
+		obj->SetActiveAction(NULL, 0, curtime);
+	}
+	else
+	{
+		BL_DeformableGameObject *obj = (BL_DeformableGameObject*)m_obj;
+		BL_ShapeDeformer *shape_deformer = dynamic_cast<BL_ShapeDeformer*>(obj->GetDeformer());
+
+		// Handle shape actions if we have any
+		if (shape_deformer && shape_deformer->GetKey())
+		{
+			Key *key = shape_deformer->GetKey();
+
+
+			animsys_evaluate_action(m_ptrrna, m_action, NULL, m_localtime);
+
+			// Handle blending between shape actions
+			if (m_blendin && m_blendframe < m_blendin)
+			{
+				IncrementBlending(curtime);
+
+				float weight = 1.f - (m_blendframe/m_blendin);
+
+				// We go through and clear out the keyblocks so there isn't any interference
+				// from other shape actions
+				KeyBlock *kb;
+				for (kb=(KeyBlock*)key->block.first; kb; kb=(KeyBlock*)kb->next)
+					kb->curval = 0.f;
+
+				// Now blend the shape
+				BlendShape(key, weight, m_blendinshape);
+			}
+
+			// Handle layer blending
+			if (m_layer_weight >= 0)
+			{
+				obj->GetShape(m_blendshape);
+				BlendShape(key, m_layer_weight, m_blendshape);
+			}
+
+			obj->SetActiveAction(NULL, 0, curtime);
+		}
+
+
+		InitIPO();
+		m_obj->UpdateIPO(m_localtime, m_ipo_flags & ACT_IPOFLAG_CHILD);
+	}
+}
diff --git a/source/gameengine/Ketsji/BL_Action.h b/source/gameengine/Ketsji/BL_Action.h
new file mode 100644
index 00000000000..92fbe95fd54
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_Action.h
@@ -0,0 +1,144 @@
+/**
+ * $Id$
+ *
+ * ***** 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): Mitchell Stokes.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file BL_Action.h
+ *  \ingroup ketsji
+ */
+
+#ifndef __BL_ACTION
+#define __BL_ACTION
+
+
+#include <vector>
+
+#ifdef WITH_CXX_GUARDEDALLOC
+#include "MEM_guardedalloc.h"
+#endif
+
+
+class BL_Action
+{
+private:
+	struct bAction* m_action;
+	struct bPose* m_pose;
+	struct bPose* m_blendpose;
+	struct bPose* m_blendinpose;
+	struct PointerRNA *m_ptrrna;
+	std::vector<class SG_Controller*> m_sg_contr_list;
+	class KX_GameObject* m_obj;
+	std::vector<float>	m_blendshape;
+	std::vector<float>	m_blendinshape;
+
+	float m_startframe;
+	float m_endframe;
+	float m_starttime;
+	float m_endtime;
+	float m_localtime;
+
+	float m_blendin;
+	float m_blendframe;
+	float m_blendstart;
+
+	float m_layer_weight;
+
+	float m_speed;
+
+	short m_priority;
+
+	short m_playmode;
+
+	short m_ipo_flags;
+
+	bool m_done;
+	bool m_calc_localtime;
+
+	void ClearControllerList();
+	void InitIPO();
+	void SetLocalTime(float curtime);
+	void ResetStartTime(float curtime);
+	void IncrementBlending(float curtime);
+	void BlendShape(struct Key* key, float srcweight, std::vector<float>& blendshape);
+public:
+	BL_Action(class KX_GameObject* gameobj);
+	~BL_Action();
+
+	/**
+	 * Play an action
+	 */
+	bool Play(const char* name,
+			float start,
+			float end,
+			short priority,
+			float blendin,
+			short play_mode,
+			float layer_weight,
+			short ipo_flags,
+			float playback_speed);
+	/**
+	 * Stop playing the action
+	 */
+	void Stop();
+	/**
+	 * Whether or not the action is still playing
+	 */
+	bool IsDone();
+	/**
+	 * Update the action's frame, etc.
+	 */
+	void Update(float curtime);
+
+	// Accessors
+	float GetFrame();
+	struct bAction *GetAction();
+
+	// Mutators
+	void SetFrame(float frame);
+	void SetPlayMode(short play_mode);
+	void SetTimes(float start, float end);
+
+	enum 
+	{
+		ACT_MODE_PLAY = 0,
+		ACT_MODE_LOOP,
+		ACT_MODE_PING_PONG,
+		ACT_MODE_MAX,
+	};
+
+	enum
+	{
+		ACT_IPOFLAG_FORCE = 1,
+		ACT_IPOFLAG_LOCAL = 2,
+		ACT_IPOFLAG_ADD = 4,
+		ACT_IPOFLAG_CHILD = 8,
+	};
+
+#ifdef WITH_CXX_GUARDEDALLOC
+public:
+	void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_Action"); }
+	void operator delete( void *mem ) { MEM_freeN(mem); }
+#endif
+};
+
+#endif //BL_ACTION
+
diff --git a/source/gameengine/Ketsji/BL_ActionManager.cpp b/source/gameengine/Ketsji/BL_ActionManager.cpp
new file mode 100644
index 00000000000..4e4d3bc539e
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_ActionManager.cpp
@@ -0,0 +1,110 @@
+/**
+ * $Id$
+ *
+ * ***** 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): Mitchell Stokes.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file BL_ActionManager.cpp
+ *  \ingroup ketsji
+ */
+
+#include "BL_ActionManager.h"
+
+BL_ActionManager::BL_ActionManager(class KX_GameObject *obj)
+{
+	for (int i=0; i<MAX_ACTION_LAYERS; ++i)
+		m_layers[i] = new BL_Action(obj);
+}
+
+BL_ActionManager::~BL_ActionManager()
+{
+	for (int i=0; i<MAX_ACTION_LAYERS; ++i)
+		delete m_layers[i];
+}
+
+float BL_ActionManager::GetActionFrame(short layer)
+{
+	return m_layers[layer]->GetFrame();
+
+	return 0.f;
+}
+
+void BL_ActionManager::SetActionFrame(short layer, float frame)
+{
+	m_layers[layer]->SetFrame(frame);
+}
+
+struct bAction *BL_ActionManager::GetCurrentAction(short layer)
+{
+	return m_layers[layer]->GetAction();
+	
+	return 0;
+}
+
+void BL_ActionManager::SetPlayMode(short layer, short mode)
+{
+	m_layers[layer]->SetPlayMode(mode);
+}
+
+void BL_ActionManager::SetTimes(short layer, float start, float end)
+{
+	m_layers[layer]->SetTimes(start, end);
+}
+
+bool BL_ActionManager::PlayAction(const char* name,
+								float start,
+								float end,
+								short layer,
+								short priority,
+								float blendin,
+								short play_mode,
+								float layer_weight,
+								short ipo_flags,
+								float playback_speed)
+{
+	// Disable layer blending on the first layer
+	if (layer == 0) layer_weight = -1.f;
+
+	return m_layers[layer]->Play(name, start, end, priority, blendin, play_mode, layer_weight, ipo_flags, playback_speed);
+}
+
+void BL_ActionManager::StopAction(short layer)
+{
+	m_layers[layer]->Stop();
+}
+
+bool BL_ActionManager::IsActionDone(short layer)
+{
+	return m_layers[layer]->IsDone();
+
+	return true;
+}
+
+void BL_ActionManager::Update(float curtime)
+{
+	for (int i=0; i<MAX_ACTION_LAYERS; ++i)
+	{
+		if (!m_layers[i]->IsDone())
+		{
+			m_layers[i]->Update(curtime);
+		}
+	}
+}
diff --git a/source/gameengine/Ketsji/BL_ActionManager.h b/source/gameengine/Ketsji/BL_ActionManager.h
new file mode 100644
index 00000000000..a3c8379981e
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_ActionManager.h
@@ -0,0 +1,106 @@
+/**
+ * $Id$
+ *
+ * ***** 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): Mitchell Stokes.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file BL_ActionManager.cpp
+ *  \ingroup ketsji
+ */
+
+#ifndef __BL_ACTIONMANAGER
+#define __BL_ACTIONMANAGER
+
+#include "BL_Action.h"
+
+#define MAX_ACTION_LAYERS 8
+
+/**
+ * BL_ActionManager is responsible for handling a KX_GameObject's actions.
+ */
+class BL_ActionManager
+{
+private:
+	BL_Action* m_layers[MAX_ACTION_LAYERS];
+
+public:
+	BL_ActionManager(class KX_GameObject* obj);
+	~BL_ActionManager();
+
+	bool PlayAction(const char* name,
+					float start,
+					float end,
+					short layer=0,
+					short priority=0,
+					float blendin=0.f,
+					short play_mode=0,
+					float layer_weight=0.f,
+					short ipo_flags=0,
+					float playback_speed=1.f);
+	/**
+	 * Gets the current frame of an action
+	 */
+	float GetActionFrame(short layer);
+
+	/**
+	 * Sets the current frame of an action
+	 */
+	void SetActionFrame(short layer, float frame);
+	
+	/**
+	 * Gets the currently running action on the given layer
+	 */
+	struct bAction *GetCurrentAction(short layer);
+
+	/**
+	 * Sets play mode of the action on the given layer
+	 */
+	void SetPlayMode(short layer, short mode);
+
+	/**
+	 * Sets the start and end times of the action on the given layer
+	 */
+	void SetTimes(short layer, float start, float end);
+
+	/**
+	 * Stop playing the action on the given layer
+	 */
+	void StopAction(short layer);
+
+	/**
+	 * Check if an action has finished playing
+	 */
+	bool IsActionDone(short layer);
+
+	/**
+	 * Update any running actions
+	 */
+	void Update(float);
+
+#ifdef WITH_CXX_GUARDEDALLOC
+public:
+	void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:BL_ActionManager"); }
+	void operator delete( void *mem ) { MEM_freeN(mem); }
+#endif
+};
+
+#endif //BL_ACTIONMANAGER
+
diff --git a/source/gameengine/Ketsji/BL_BlenderShader.cpp b/source/gameengine/Ketsji/BL_BlenderShader.cpp
index 91982a424c7..4ae937cdcd6 100644
--- a/source/gameengine/Ketsji/BL_BlenderShader.cpp
+++ b/source/gameengine/Ketsji/BL_BlenderShader.cpp
@@ -63,7 +63,7 @@ int BL_BlenderShader::GetAttribNum()
 
 	GPU_material_vertex_attributes(mGPUMat, &attribs);
 
-    for(i = 0; i < attribs.totlayer; i++)
+	for(i = 0; i < attribs.totlayer; i++)
 		if(attribs.layer[i].glindex+1 > enabled)
 			enabled= attribs.layer[i].glindex+1;
 	
diff --git a/source/gameengine/Ketsji/BL_Material.h b/source/gameengine/Ketsji/BL_Material.h
index ef25c9218a3..c0440e66501 100644
--- a/source/gameengine/Ketsji/BL_Material.h
+++ b/source/gameengine/Ketsji/BL_Material.h
@@ -157,7 +157,8 @@ enum BL_ras_mode
 	ALPHA=8,
 	// TRIANGLE=16,
 	USE_LIGHT=32,
-	WIRE=64
+	WIRE=64,
+	CAST_SHADOW=128
 };
 
 // -------------------------------------
diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 621cabfe0cf..aea33246a3f 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -690,7 +690,7 @@ void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
 		float value[9];
 		value[0] = (float)vec[0][0]; value[1] = (float)vec[1][0]; value[2] = (float)vec[2][0]; 
 		value[3] = (float)vec[0][1]; value[4] = (float)vec[1][1]; value[5] = (float)vec[2][1]; 
-		value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[7] = (float)vec[2][2]; 
+		value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[8] = (float)vec[2][2];
 		glUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 	}
 }
diff --git a/source/gameengine/Ketsji/BL_Texture.cpp b/source/gameengine/Ketsji/BL_Texture.cpp
index d2438a66367..a306e059442 100644
--- a/source/gameengine/Ketsji/BL_Texture.cpp
+++ b/source/gameengine/Ketsji/BL_Texture.cpp
@@ -28,6 +28,7 @@
 #define spit(x) std::cout << x << std::endl;
 
 #include "MEM_guardedalloc.h"
+#include "GPU_draw.h"
 
 extern "C" {
 	// envmaps
@@ -175,6 +176,8 @@ void BL_Texture::InitGLTex(unsigned int *pix,int x,int y,bool mipmap)
 		glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix );
 	}
 
+	if (GLEW_EXT_texture_filter_anisotropic)
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GPU_get_anisotropic());
 	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 }
 
@@ -199,6 +202,9 @@ void BL_Texture::InitNonPow2Tex(unsigned int *pix,int x,int y,bool mipmap)
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 		glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, nx, ny, 0, GL_RGBA, GL_UNSIGNED_BYTE, newPixels );
 	}
+
+	if (GLEW_EXT_texture_filter_anisotropic)
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GPU_get_anisotropic());
 	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 	free(newPixels);
 }
diff --git a/source/gameengine/Ketsji/CMakeLists.txt b/source/gameengine/Ketsji/CMakeLists.txt
index b32fd9e7a44..6846da5b019 100644
--- a/source/gameengine/Ketsji/CMakeLists.txt
+++ b/source/gameengine/Ketsji/CMakeLists.txt
@@ -26,33 +26,33 @@
 
 set(INC
 	.
-	../../../intern/string
-	../../../intern/guardedalloc
+	KXNetwork
+	../BlenderRoutines
+	../Converter
+	../Expressions
+	../GameLogic
+	../Network
+	../Network/LoopBackNetwork
+	../Physics/common
+	../Rasterizer
+	../Rasterizer/RAS_OpenGLRasterizer
+	../SceneGraph
+	../../blender
+	../../blender/blenfont
+	../../blender/blenkernel
+	../../blender/blenlib
+	../../blender/blenloader
+	../../blender/gpu
+	../../blender/imbuf
+	../../blender/makesdna
+	../../blender/makesrna
+	../../blender/python
+	../../blender/python/generic
+	../../blender/python/mathutils
 	../../../intern/container
-	../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer 
-	../../../source/gameengine/Converter
-	../../../source/gameengine/BlenderRoutines
-	../../../source/blender/imbuf
+	../../../intern/guardedalloc
 	../../../intern/moto/include
-	../../../source/gameengine/Ketsji 
-	../../../source/blender/blenlib
-	../../../source/blender/blenfont
-	../../../source/blender/blenkernel
-	../../../source/blender/python
-	../../../source/blender/python/generic
-	../../../source/blender 
-	../../../source/blender/makesdna 
-	../../../source/gameengine/Rasterizer 
-	../../../source/gameengine/GameLogic
-	../../../source/gameengine/Expressions 
-	../../../source/gameengine/Ketsji/KXNetwork
-	../../../source/gameengine/Network
-	../../../source/gameengine/SceneGraph 
-	../../../source/gameengine/Physics/common
-	../../../source/gameengine/Network/LoopBackNetwork
-	../../../intern/audaspace/intern
-	../../../source/blender/blenloader
-	../../../source/blender/gpu
+	../../../intern/string
 )
 
 set(INC_SYS
@@ -63,6 +63,8 @@ set(INC_SYS
 )
 
 set(SRC
+	BL_Action.cpp
+	BL_ActionManager.cpp
 	BL_BlenderShader.cpp
 	BL_Material.cpp
 	BL_Shader.cpp
@@ -135,6 +137,12 @@ set(SRC
 	KX_WorldInfo.cpp
 	KX_WorldIpoController.cpp
 
+	BL_Action.h
+	BL_ActionManager.h
+	BL_BlenderShader.h
+	BL_Material.h
+	BL_Shader.h
+	BL_Texture.h
 	KX_ArmatureSensor.h
 	KX_BlenderMaterial.h
 	KX_BulletPhysicsController.h
@@ -210,16 +218,14 @@ set(SRC
 	KX_VisibilityActuator.h
 	KX_WorldInfo.h
 	KX_WorldIpoController.h
-	BL_BlenderShader.h
-	BL_Material.h
-	BL_Shader.h
-	BL_Texture.h
 )
 
 add_definitions(-DGLEW_STATIC)
 
 if(WITH_SDL)
-	list(APPEND INC_SYS ${SDL_INCLUDE_DIR})  
+	list(APPEND INC_SYS
+		${SDL_INCLUDE_DIR}
+	)
 else()
 	add_definitions(-DDISABLE_SDL)
 endif()
@@ -228,10 +234,18 @@ if(WITH_CODEC_FFMPEG)
 	add_definitions(-DWITH_FFMPEG)
 endif()
 
+if(WITH_AUDASPACE)
+	list(APPEND INC
+		../../../intern/audaspace/intern
+		../../../intern/audaspace/FX
+	)
+	add_definitions(-DWITH_AUDASPACE)
+endif()
+
 if(WITH_BULLET)
 	list(APPEND INC
 		../../../extern/bullet2/src
-		../../../source/gameengine/Physics/Bullet
+		../Physics/Bullet
 	)
 	add_definitions(-DUSE_BULLET)
 endif()
diff --git a/source/gameengine/Ketsji/KXNetwork/CMakeLists.txt b/source/gameengine/Ketsji/KXNetwork/CMakeLists.txt
index b8149566801..1ebf1153150 100644
--- a/source/gameengine/Ketsji/KXNetwork/CMakeLists.txt
+++ b/source/gameengine/Ketsji/KXNetwork/CMakeLists.txt
@@ -26,14 +26,14 @@
 
 set(INC
 	.
-	../../../../intern/string
+	..
+	../../Expressions
+	../../GameLogic
+	../../Network
+	../../SceneGraph
 	../../../../intern/container
 	../../../../intern/moto/include
-	../../../../source/gameengine/Ketsji
-	../../../../source/gameengine/GameLogic
-	../../../../source/gameengine/Expressions
-	../../../../source/gameengine/SceneGraph
-	../../../../source/gameengine/Network
+	../../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.cpp b/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.cpp
index e8e65371d3a..72f1cee8855 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.cpp
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.cpp
@@ -66,8 +66,8 @@ void KX_NetworkEventManager::NextFrame()
 	for (it.begin();!it.end();++it)
 	{
 //	    printf("KX_NetworkEventManager::proceed sensor %.2f\n", curtime);
-	    // process queue
-	    (*it)->Activate(m_logicmgr);
+		// process queue
+		(*it)->Activate(m_logicmgr);
 	}
 
 	// now a list of triggerer sensors has been built
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.h b/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.h
index ff9131f464e..405e2d52989 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.h
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkEventManager.h
@@ -43,7 +43,7 @@ class KX_NetworkEventManager : public SCA_EventManager
 
 public:
 	KX_NetworkEventManager(class SCA_LogicManager* logicmgr,
-			       class NG_NetworkDeviceInterface *ndi);
+	                       class NG_NetworkDeviceInterface *ndi);
 	virtual ~KX_NetworkEventManager ();
 
 	virtual void NextFrame();
@@ -51,7 +51,7 @@ public:
 
 	SCA_LogicManager* GetLogicManager() { return m_logicmgr; }
 	class NG_NetworkDeviceInterface* GetNetworkDevice() {
-	    return m_ndi; }
+		return m_ndi; }
 };
 
 #endif //KX_NETWORK_EVENTMANAGER_H
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
index 2e0abc0290c..9fd09506c0d 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
@@ -91,8 +91,7 @@ bool KX_NetworkMessageActuator::Update()
 
 CValue* KX_NetworkMessageActuator::GetReplica()
 {
-	KX_NetworkMessageActuator* replica =
-	    new KX_NetworkMessageActuator(*this);
+	KX_NetworkMessageActuator* replica = new KX_NetworkMessageActuator(*this);
 	replica->ProcessReplica();
 
 	return replica;
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
index 6dcf50fa18f..a795a4eddc6 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageSensor.cpp
@@ -50,11 +50,11 @@
 #endif
 
 KX_NetworkMessageSensor::KX_NetworkMessageSensor(
-	class KX_NetworkEventManager* eventmgr,	// our eventmanager
-	class NG_NetworkScene *NetworkScene,	// our scene
-	SCA_IObject* gameobj,					// the sensor controlling object
-	const STR_String &subject
-) :
+        class KX_NetworkEventManager* eventmgr,	// our eventmanager
+        class NG_NetworkScene *NetworkScene,	// our scene
+        SCA_IObject* gameobj,					// the sensor controlling object
+        const STR_String &subject
+        ) :
     SCA_ISensor(gameobj,eventmgr),
     m_NetworkScene(NetworkScene),
     m_subject(subject),
@@ -67,7 +67,7 @@ KX_NetworkMessageSensor::KX_NetworkMessageSensor(
 
 void KX_NetworkMessageSensor::Init()
 {
-    m_IsUp = false;
+	m_IsUp = false;
 }
 
 KX_NetworkMessageSensor::~KX_NetworkMessageSensor()
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index 9ff32ba57c5..33da17cc505 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -56,21 +56,21 @@ KX_BlenderMaterial::KX_BlenderMaterial()
 }
 
 void KX_BlenderMaterial::Initialize(
-    KX_Scene *scene,
-	BL_Material *data)
+        KX_Scene *scene,
+        BL_Material *data)
 {
 	RAS_IPolyMaterial::Initialize(
-		data->texname[0],
-		data->matname,
-		data->materialindex,
-		data->tile,
-		data->tilexrep[0],
-		data->tileyrep[0],
-		data->mode,
-		data->transp,
-		((data->ras_mode &ALPHA)!=0),
-		((data->ras_mode &ZSORT)!=0)
-	);
+	            data->texname[0],
+	            data->matname,
+	            data->materialindex,
+	            data->tile,
+	            data->tilexrep[0],
+	            data->tileyrep[0],
+	            data->mode,
+	            data->transp,
+	            ((data->ras_mode &ALPHA)!=0),
+	            ((data->ras_mode &ZSORT)!=0)
+	            );
 	mMaterial = data;
 	mShader = 0;
 	mBlenderShader = 0;
@@ -80,11 +80,12 @@ void KX_BlenderMaterial::Initialize(
 	mConstructed = false;
 	mPass = 0;
 	// --------------------------------
-	// RAS_IPolyMaterial variables... 
+	// RAS_IPolyMaterial variables...
 	m_flag |= RAS_BLENDERMAT;
 	m_flag |= (mMaterial->IdMode>=ONETEX)? RAS_MULTITEX: 0;
 	m_flag |= ((mMaterial->ras_mode & USE_LIGHT)!=0)? RAS_MULTILIGHT: 0;
 	m_flag |= (mMaterial->glslmat)? RAS_BLENDERGLSL: 0;
+	m_flag |= ((mMaterial->ras_mode & CAST_SHADOW)!=0)? RAS_CASTSHADOW: 0;
 
 	// figure max
 	int enabled = mMaterial->num_enabled;
@@ -92,14 +93,11 @@ void KX_BlenderMaterial::Initialize(
 	mMaterial->num_enabled = enabled>=max?max:enabled;
 
 	// test the sum of the various modes for equality
-	// so we can ether accept or reject this material 
-	// as being equal, this is rather important to 
+	// so we can ether accept or reject this material
+	// as being equal, this is rather important to
 	// prevent material bleeding
 	for(int i=0; i<mMaterial->num_enabled; i++) {
-		m_multimode	+=
-			( mMaterial->flag[i]	+
-			  mMaterial->blend_mode[i]
-			 );
+		m_multimode	+= (mMaterial->flag[i] + mMaterial->blend_mode[i]);
 	}
 	m_multimode += mMaterial->IdMode+ (mMaterial->ras_mode & ~(COLLIDER|USE_LIGHT));
 }
diff --git a/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp b/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
index fde01961fd5..6e5513991f9 100644
--- a/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
+++ b/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
@@ -213,16 +213,16 @@ MT_Scalar	KX_BulletPhysicsController::GetMass()
 
 MT_Vector3 KX_BulletPhysicsController::GetLocalInertia()
 {
-    MT_Vector3 inertia(0.f, 0.f, 0.f);
-    btVector3 inv_inertia;
-    if (GetRigidBody()) {
-        inv_inertia = GetRigidBody()->getInvInertiaDiagLocal();
-		if (!btFuzzyZero(inv_inertia.getX()) && 
-			!btFuzzyZero(inv_inertia.getY()) && 
-			!btFuzzyZero(inv_inertia.getZ()))
+	MT_Vector3 inertia(0.f, 0.f, 0.f);
+	btVector3 inv_inertia;
+	if (GetRigidBody()) {
+		inv_inertia = GetRigidBody()->getInvInertiaDiagLocal();
+		if (!btFuzzyZero(inv_inertia.getX()) &&
+		        !btFuzzyZero(inv_inertia.getY()) &&
+		        !btFuzzyZero(inv_inertia.getZ()))
 			inertia = MT_Vector3(1.f/inv_inertia.getX(), 1.f/inv_inertia.getY(), 1.f/inv_inertia.getZ());
-    }
-    return inertia;
+	}
+	return inertia;
 }
 
 MT_Vector3	KX_BulletPhysicsController::getReactionForce()
diff --git a/source/gameengine/Ketsji/KX_Camera.cpp b/source/gameengine/Ketsji/KX_Camera.cpp
index 98ea25c135a..a488d646792 100644
--- a/source/gameengine/Ketsji/KX_Camera.cpp
+++ b/source/gameengine/Ketsji/KX_Camera.cpp
@@ -271,18 +271,18 @@ void KX_Camera::ExtractFrustumSphere()
 	if (m_set_frustum_center)
 		return;
 
-    // compute sphere for the general case and not only symmetric frustum:
-    // the mirror code in ImageRender can use very asymmetric frustum.
-    // We will put the sphere center on the line that goes from origin to the center of the far clipping plane
-    // This is the optimal position if the frustum is symmetric or very asymmetric and probably close
-    // to optimal for the general case. The sphere center position is computed so that the distance to 
-    // the near and far extreme frustum points are equal.
-
-    // get the transformation matrix from device coordinate to camera coordinate
+	// compute sphere for the general case and not only symmetric frustum:
+	// the mirror code in ImageRender can use very asymmetric frustum.
+	// We will put the sphere center on the line that goes from origin to the center of the far clipping plane
+	// This is the optimal position if the frustum is symmetric or very asymmetric and probably close
+	// to optimal for the general case. The sphere center position is computed so that the distance to
+	// the near and far extreme frustum points are equal.
+
+	// get the transformation matrix from device coordinate to camera coordinate
 	MT_Matrix4x4 clip_camcs_matrix = m_projection_matrix;
 	clip_camcs_matrix.invert();
 
-	if (m_projection_matrix[3][3] == MT_Scalar(0.0)) 
+	if (m_projection_matrix[3][3] == MT_Scalar(0.0))
 	{
 		// frustrum projection
 		// detect which of the corner of the far clipping plane is the farthest to the origin
@@ -302,7 +302,7 @@ void KX_Camera::ExtractFrustumSphere()
 		MT_Scalar len;
 		for (int i=0; i<4; i++)
 		{
-    		hpoint = clip_camcs_matrix*npoint;
+			hpoint = clip_camcs_matrix*npoint;
 			point.setValue(hpoint[0]/hpoint[3], hpoint[1]/hpoint[3], hpoint[2]/hpoint[3]);
 			len = point.dot(point);
 			if (len > F)
@@ -321,7 +321,7 @@ void KX_Camera::ExtractFrustumSphere()
 		farcenter *= 0.25;
 		// the extreme near point is the opposite point on the near clipping plane
 		nfar.setValue(-nfar[0], -nfar[1], -1., 1.);
-   		nfar = clip_camcs_matrix*nfar;
+		nfar = clip_camcs_matrix*nfar;
 		nearpoint.setValue(nfar[0]/nfar[3], nfar[1]/nfar[3], nfar[2]/nfar[3]);
 		// this is a frustrum projection
 		N = nearpoint.dot(nearpoint);
@@ -340,7 +340,7 @@ void KX_Camera::ExtractFrustumSphere()
 		z = (F-N)/(2.0*(e-s+c*(f-n)));
 		m_frustum_center = MT_Point3(farcenter[0]*z/e, farcenter[1]*z/e, z);
 		m_frustum_radius = m_frustum_center.distance(farpoint);
-	} 
+	}
 	else
 	{
 		// orthographic projection
@@ -923,6 +923,8 @@ KX_PYMETHODDEF_DOC_O(KX_Camera, getScreenPosition,
 
 	if (!PyVecTo(value, vect))
 	{
+		PyErr_Clear();
+
 		if(ConvertPythonToGameObject(value, &obj, true, ""))
 		{
 			PyErr_Clear();
@@ -1020,10 +1022,8 @@ KX_PYMETHODDEF_DOC_VARARGS(KX_Camera, getScreenRay,
 		return NULL;
 
 	PyObject* argValue = PyTuple_New(2);
-	if (argValue) {
-		PyTuple_SET_ITEM(argValue, 0, PyFloat_FromDouble(x));
-		PyTuple_SET_ITEM(argValue, 1, PyFloat_FromDouble(y));
-	}
+	PyTuple_SET_ITEM(argValue, 0, PyFloat_FromDouble(x));
+	PyTuple_SET_ITEM(argValue, 1, PyFloat_FromDouble(y));
 
 	if(!PyVecTo(PygetScreenVect(argValue), vect))
 	{
diff --git a/source/gameengine/Ketsji/KX_CameraActuator.cpp b/source/gameengine/Ketsji/KX_CameraActuator.cpp
index d68cb453fe8..ebb291b2284 100644
--- a/source/gameengine/Ketsji/KX_CameraActuator.cpp
+++ b/source/gameengine/Ketsji/KX_CameraActuator.cpp
@@ -54,14 +54,16 @@ KX_CameraActuator::KX_CameraActuator(
 	float hght,
 	float minhght,
 	float maxhght,
-	bool  xytog
+	bool  xytog,
+	float damping
 ): 
 	SCA_IActuator(gameobj, KX_ACT_CAMERA),
 	m_ob (obj),
 	m_height (hght),
 	m_minHeight (minhght),
 	m_maxHeight (maxhght),
-	m_x (xytog)
+	m_x (xytog),
+	m_damping (damping)
 {
 	if (m_ob)
 		m_ob->RegisterActuator(this);
@@ -283,7 +285,7 @@ bool KX_CameraActuator::Update(double curtime, bool frame)
 	}
 	
 	inp= fp1[0]*fp2[0] + fp1[1]*fp2[1] + fp1[2]*fp2[2];
-	fac= (-1.0 + inp)/32.0;
+	fac= (-1.0 + inp) * m_damping;
 
 	from[0]+= fac*fp1[0];
 	from[1]+= fac*fp1[1];
@@ -390,6 +392,7 @@ PyAttributeDef KX_CameraActuator::Attributes[] = {
 	KX_PYATTRIBUTE_FLOAT_RW("height",-FLT_MAX,FLT_MAX,KX_CameraActuator,m_height),
 	KX_PYATTRIBUTE_BOOL_RW("useXY",KX_CameraActuator,m_x),
 	KX_PYATTRIBUTE_RW_FUNCTION("object", KX_CameraActuator, pyattr_get_object,	pyattr_set_object),
+	KX_PYATTRIBUTE_FLOAT_RW("damping",0.f,10.f,KX_CameraActuator,m_damping),
 	{NULL}
 };
 
diff --git a/source/gameengine/Ketsji/KX_CameraActuator.h b/source/gameengine/Ketsji/KX_CameraActuator.h
index d59fcff9370..f844f6418b8 100644
--- a/source/gameengine/Ketsji/KX_CameraActuator.h
+++ b/source/gameengine/Ketsji/KX_CameraActuator.h
@@ -73,6 +73,9 @@ private :
 	
 	/** xy toggle (pick one): true == x, false == y */
 	bool m_x;
+	
+	/** damping (float), */
+	float m_damping;
 
 	/* get the KX_IGameObject with this name */
 	CValue *findObject(char *obName);
@@ -95,7 +98,8 @@ private :
 		float hght,
 		float minhght,
 		float maxhght,
-		bool xytog
+		bool xytog,
+		float damping
 	);
 
 
diff --git a/source/gameengine/Ketsji/KX_Dome.cpp b/source/gameengine/Ketsji/KX_Dome.cpp
index 2e1fb933ad0..00c5e5803a8 100644
--- a/source/gameengine/Ketsji/KX_Dome.cpp
+++ b/source/gameengine/Ketsji/KX_Dome.cpp
@@ -42,34 +42,34 @@ Developed as part of a Research and Development project for SAT - La Société d
 
 // constructor
 KX_Dome::KX_Dome (
-	RAS_ICanvas* canvas,
-    /// rasterizer
-    RAS_IRasterizer* rasterizer,
-    /// render tools
-    RAS_IRenderTools* rendertools,
-    /// engine
-    KX_KetsjiEngine* engine,
-
-	short res,		//resolution of the mesh
-	short mode,		//mode - fisheye, truncated, warped, panoramic, ...
-	short angle,
-	float resbuf,	//size adjustment of the buffer
-	short tilt,
-	struct Text* warptext
-
-):
-	dlistSupported(false),
-	canvaswidth(-1), canvasheight(-1),
-	m_drawingmode(engine->GetDrawType()),
-	m_resolution(res),
-	m_mode(mode),
-	m_angle(angle),
-	m_resbuffer(resbuf),
-	m_tilt(tilt),
-	m_canvas(canvas),
-	m_rasterizer(rasterizer),
-	m_rendertools(rendertools),
-	m_engine(engine)
+        RAS_ICanvas* canvas,
+        /// rasterizer
+        RAS_IRasterizer* rasterizer,
+        /// render tools
+        RAS_IRenderTools* rendertools,
+        /// engine
+        KX_KetsjiEngine* engine,
+
+        short res,		//resolution of the mesh
+        short mode,		//mode - fisheye, truncated, warped, panoramic, ...
+        short angle,
+        float resbuf,	//size adjustment of the buffer
+        short tilt,
+        struct Text* warptext
+
+        ):
+    dlistSupported(false),
+    canvaswidth(-1), canvasheight(-1),
+    m_drawingmode(engine->GetDrawType()),
+    m_resolution(res),
+    m_mode(mode),
+    m_angle(angle),
+    m_resbuffer(resbuf),
+    m_tilt(tilt),
+    m_canvas(canvas),
+    m_rasterizer(rasterizer),
+    m_rendertools(rendertools),
+    m_engine(engine)
 {
 	warp.usemesh = false;
 	fboSupported = false;
@@ -1984,9 +1984,9 @@ void KX_Dome::DrawDomeWarped(void)
 	int can_width = m_viewport.GetRight();
 	int can_height = m_viewport.GetTop();
 
-	double screen_ratio = can_width/ (double) can_height;	
+	double screen_ratio = can_width/ (double) can_height;
 
-    glOrtho(-screen_ratio,screen_ratio,-1.0,1.0,-20.0,10.0);
+	glOrtho(-screen_ratio,screen_ratio,-1.0,1.0,-20.0,10.0);
 
 
 	glMatrixMode(GL_TEXTURE);
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index d4ef462fb27..ae8d7094015 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -75,6 +75,8 @@ typedef unsigned long uint_ptr;
 #include "NG_NetworkScene.h" //Needed for sendMessage()
 #include "KX_ObstacleSimulation.h"
 
+#include "BL_ActionManager.h"
+
 #include "PyObjectPlus.h" /* python stuff */
 
 // This file defines relationships between parents and children
@@ -86,32 +88,33 @@ typedef unsigned long uint_ptr;
 
 static MT_Point3 dummy_point= MT_Point3(0.0, 0.0, 0.0);
 static MT_Vector3 dummy_scaling = MT_Vector3(1.0, 1.0, 1.0);
-static MT_Matrix3x3 dummy_orientation = MT_Matrix3x3(	1.0, 0.0, 0.0,
-														0.0, 1.0, 0.0,
-														0.0, 0.0, 1.0);
+static MT_Matrix3x3 dummy_orientation = MT_Matrix3x3(1.0, 0.0, 0.0,
+                                                     0.0, 1.0, 0.0,
+                                                     0.0, 0.0, 1.0);
 
 KX_GameObject::KX_GameObject(
-	void* sgReplicationInfo,
-	SG_Callbacks callbacks)
-	: SCA_IObject(),
-	m_bDyna(false),
-	m_layer(0),
-	m_pBlenderObject(NULL),
-	m_pBlenderGroupObject(NULL),
-	m_bSuspendDynamics(false),
-	m_bUseObjectColor(false),
-	m_bIsNegativeScaling(false),
-	m_bVisible(true),
-	m_bCulled(true),
-	m_bOccluder(false),
-	m_pPhysicsController1(NULL),
-	m_pGraphicController(NULL),
-	m_xray(false),
-	m_pHitObject(NULL),
-	m_isDeformable(false),
-	m_pObstacleSimulation(NULL)
+        void* sgReplicationInfo,
+        SG_Callbacks callbacks)
+    : SCA_IObject(),
+      m_bDyna(false),
+      m_layer(0),
+      m_pBlenderObject(NULL),
+      m_pBlenderGroupObject(NULL),
+      m_bSuspendDynamics(false),
+      m_bUseObjectColor(false),
+      m_bIsNegativeScaling(false),
+      m_bVisible(true),
+      m_bCulled(true),
+      m_bOccluder(false),
+      m_pPhysicsController1(NULL),
+      m_pGraphicController(NULL),
+      m_xray(false),
+      m_pHitObject(NULL),
+      m_actionManager(NULL),
+      m_isDeformable(false),
+      m_pObstacleSimulation(NULL)
 #ifdef WITH_PYTHON
-	, m_attr_dict(NULL)
+    , m_attr_dict(NULL)
 #endif
 {
 	m_ignore_activity_culling = false;
@@ -162,6 +165,11 @@ KX_GameObject::~KX_GameObject()
 		m_pObstacleSimulation->DestroyObstacleForObj(this);
 	}
 
+	if (m_actionManager)
+	{
+		KX_GetActiveScene()->RemoveAnimatedObject(this);
+		delete m_actionManager;
+	}
 #ifdef WITH_PYTHON
 	if (m_attr_dict) {
 		PyDict_Clear(m_attr_dict); /* incase of circular refs or other weird cases */
@@ -335,7 +343,7 @@ void KX_GameObject::RemoveParent(KX_Scene *scene)
 				rootobj->m_pPhysicsController1->RemoveCompoundChild(m_pPhysicsController1);
 			}
 			m_pPhysicsController1->RestoreDynamics();
-			if (m_pPhysicsController1->IsDyna() && rootobj->m_pPhysicsController1)
+			if (m_pPhysicsController1->IsDyna() && (rootobj != NULL && rootobj->m_pPhysicsController1))
 			{
 				// dynamic object should remember the velocity they had while being parented
 				MT_Point3 childPoint = GetSGNode()->GetWorldPosition();
@@ -352,6 +360,69 @@ void KX_GameObject::RemoveParent(KX_Scene *scene)
 	}
 }
 
+BL_ActionManager* KX_GameObject::GetActionManager()
+{
+	// We only want to create an action manager if we need it
+	if (!m_actionManager)
+	{		KX_GetActiveScene()->AddAnimatedObject(this);		m_actionManager = new BL_ActionManager(this);
+	}
+	return m_actionManager;
+}
+
+bool KX_GameObject::PlayAction(const char* name,
+								float start,
+								float end,
+								short layer,
+								short priority,
+								float blendin,
+								short play_mode,
+								float layer_weight,
+								short ipo_flags,
+								float playback_speed)
+{
+	return GetActionManager()->PlayAction(name, start, end, layer, priority, blendin, play_mode, layer_weight, ipo_flags, playback_speed);
+}
+
+void KX_GameObject::StopAction(short layer)
+{
+	GetActionManager()->StopAction(layer);
+}
+
+bool KX_GameObject::IsActionDone(short layer)
+{
+	return GetActionManager()->IsActionDone(layer);
+}
+
+void KX_GameObject::UpdateActionManager(float curtime)
+{
+	GetActionManager()->Update(curtime);
+}
+
+float KX_GameObject::GetActionFrame(short layer)
+{
+	return GetActionManager()->GetActionFrame(layer);
+}
+
+void KX_GameObject::SetActionFrame(short layer, float frame)
+{
+	GetActionManager()->SetActionFrame(layer, frame);
+}
+
+bAction *KX_GameObject::GetCurrentAction(short layer)
+{
+	return GetActionManager()->GetCurrentAction(layer);
+}
+
+void KX_GameObject::SetPlayMode(short layer, short mode)
+{
+	GetActionManager()->SetPlayMode(layer, mode);
+}
+
+void KX_GameObject::SetTimes(short layer, float start, float end)
+{
+	GetActionManager()->SetTimes(layer, start, end);
+}
+
 void KX_GameObject::ProcessReplica()
 {
 	SCA_IObject::ProcessReplica();
@@ -361,6 +432,8 @@ void KX_GameObject::ProcessReplica()
 	m_pSGNode = NULL;
 	m_pClient_info = new KX_ClientObjectInfo(*m_pClient_info);
 	m_pClient_info->m_gameobject = this;
+	if (m_actionManager)
+		m_actionManager = new BL_ActionManager(this);
 	m_state = 0;
 
 	KX_Scene* scene = KX_GetActiveScene();
@@ -1513,6 +1586,12 @@ PyMethodDef KX_GameObject::Methods[] = {
 	KX_PYMETHODTABLE_O(KX_GameObject, getDistanceTo),
 	KX_PYMETHODTABLE_O(KX_GameObject, getVectTo),
 	KX_PYMETHODTABLE(KX_GameObject, sendMessage),
+
+	KX_PYMETHODTABLE_KEYWORDS(KX_GameObject, playAction),
+	KX_PYMETHODTABLE(KX_GameObject, stopAction),
+	KX_PYMETHODTABLE(KX_GameObject, getActionFrame),
+	KX_PYMETHODTABLE(KX_GameObject, setActionFrame),
+	KX_PYMETHODTABLE(KX_GameObject, isPlayingAction),
 	
 	// dict style access for props
 	{"get",(PyCFunction) KX_GameObject::sPyget, METH_VARARGS},
@@ -1855,7 +1934,7 @@ PyObject* KX_GameObject::pyattr_get_lin_vel_min(void *self_v, const KX_PYATTRIBU
 {
 	KX_GameObject* self= static_cast<KX_GameObject*>(self_v);
 	KX_IPhysicsController *spc = self->GetPhysicsController();
-	return PyFloat_FromDouble(spc ? spc->GetLinVelocityMax() : 0.0f);
+	return PyFloat_FromDouble(spc ? spc->GetLinVelocityMin() : 0.0f);
 }
 
 int KX_GameObject::pyattr_set_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
@@ -2991,6 +3070,112 @@ KX_PYMETHODDEF_DOC_VARARGS(KX_GameObject, sendMessage,
 	Py_RETURN_NONE;
 }
 
+static void layer_check(short &layer, const char *method_name)
+{
+	if (layer < 0 || layer >= MAX_ACTION_LAYERS)
+	{
+		printf("KX_GameObject.%s(): given layer (%d) is out of range (0 - %d), setting to 0.\n", method_name, layer, MAX_ACTION_LAYERS-1);
+		layer = 0;
+	}
+}
+
+KX_PYMETHODDEF_DOC(KX_GameObject, playAction,
+	"playAction(name, start_frame, end_frame, layer=0, priority=0 blendin=0, play_mode=ACT_MODE_PLAY, layer_weight=0.0, ipo_flags=0, speed=1.0)\n"
+	"Plays an action\n")
+{
+	const char* name;
+	float start, end, blendin=0.f, speed=1.f, layer_weight=0.f;
+	short layer=0, priority=0;
+	short ipo_flags=0;
+	short play_mode=0;
+
+	static const char *kwlist[] = {"name", "start_frame", "end_frame", "layer", "priority", "blendin", "play_mode", "layer_weight", "ipo_flags", "speed", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "sff|hhfhfhf:playAction", const_cast<char**>(kwlist),
+									&name, &start, &end, &layer, &priority, &blendin, &play_mode, &layer_weight, &ipo_flags, &speed))
+		return NULL;
+
+	layer_check(layer, "playAction");
+
+	if (play_mode < 0 || play_mode > BL_Action::ACT_MODE_MAX)
+	{
+		printf("KX_GameObject.playAction(): given play_mode (%d) is out of range (0 - %d), setting to ACT_MODE_PLAY", play_mode, BL_Action::ACT_MODE_MAX-1);
+		play_mode = BL_Action::ACT_MODE_MAX;
+	}
+
+	if (layer_weight < 0.f || layer_weight > 1.f)
+	{
+		printf("KX_GameObject.playAction(): given layer_weight (%f) is out of range (0.0 - 1.0), setting to 0.0", layer_weight);
+		layer_weight = 0.f;
+	}
+
+	PlayAction(name, start, end, layer, priority, blendin, play_mode, layer_weight, ipo_flags, speed);
+
+	Py_RETURN_NONE;
+}
+
+KX_PYMETHODDEF_DOC(KX_GameObject, stopAction,
+	"stopAction(layer=0)\n"
+	"Stop playing the action on the given layer\n")
+{
+	short layer=0;
+
+	if (!PyArg_ParseTuple(args, "|h:stopAction", &layer))
+		return NULL;
+
+	layer_check(layer, "stopAction");
+
+	StopAction(layer);
+
+	Py_RETURN_NONE;
+}
+
+KX_PYMETHODDEF_DOC(KX_GameObject, getActionFrame,
+	"getActionFrame(layer=0)\n"
+	"Gets the current frame of the action playing in the supplied layer\n")
+{
+	short layer=0;
+
+	if (!PyArg_ParseTuple(args, "|h:getActionFrame", &layer))
+		return NULL;
+
+	layer_check(layer, "getActionFrame");
+
+	return PyFloat_FromDouble(GetActionFrame(layer));
+}
+
+KX_PYMETHODDEF_DOC(KX_GameObject, setActionFrame,
+	"setActionFrame(frame, layer=0)\n"
+	"Set the current frame of the action playing in the supplied layer\n")
+{
+	short layer=0;
+	float frame;
+
+	if (!PyArg_ParseTuple(args, "f|h:setActionFrame", &frame, &layer))
+		return NULL;
+
+	layer_check(layer, "setActionFrame");
+
+	SetActionFrame(layer, frame);
+
+	Py_RETURN_NONE;
+}
+
+KX_PYMETHODDEF_DOC(KX_GameObject, isPlayingAction,
+	"isPlayingAction(layer=0)\n"
+	"Checks to see if there is an action playing in the given layer\n")
+{
+	short layer=0;
+
+	if (!PyArg_ParseTuple(args, "|h:isPlayingAction", &layer))
+		return NULL;
+
+	layer_check(layer, "isPlayingAction");
+
+	return PyBool_FromLong(!IsActionDone(layer));
+}
+
+
 /* dict style access */
 
 
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index 2ea6e9552a2..655bc9ff080 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -63,8 +63,10 @@ class RAS_MeshObject;
 class KX_IPhysicsController;
 class PHY_IGraphicController;
 class PHY_IPhysicsEnvironment;
+class BL_ActionManager;
 struct Object;
 class KX_ObstacleSimulation;
+struct bAction;
 
 #ifdef WITH_PYTHON
 /* utility conversion function */
@@ -116,6 +118,12 @@ protected:
 
 	KX_ObstacleSimulation*				m_pObstacleSimulation;
 
+
+	// The action manager is used to play/stop/update actions
+	BL_ActionManager*				m_actionManager;
+
+	BL_ActionManager* GetActionManager();
+	
 public:
 	bool								m_isDeformable;
 
@@ -201,6 +209,68 @@ public:
 	 */			
 	void RemoveParent(KX_Scene *scene);
 
+	/*********************************
+	 * Animation API
+	 *********************************/
+
+	/**
+	 * Adds an action to the object's action manager
+	 */
+	bool PlayAction(const char* name,
+					float start,
+					float end,
+					short layer=0,
+					short priority=0,
+					float blendin=0.f,
+					short play_mode=0,
+					float layer_weight=0.f,
+					short ipo_flags=0,
+					float playback_speed=1.f);
+
+	/**
+	 * Gets the current frame of an action
+	 */
+	float GetActionFrame(short layer);
+
+	/**
+	 * Sets the current frame of an action
+	 */
+	void SetActionFrame(short layer, float frame);
+
+	/**
+	 * Gets the currently running action on the given layer
+	 */
+	bAction *GetCurrentAction(short layer);
+
+	/**
+	 * Sets play mode of the action on the given layer
+	 */
+	void SetPlayMode(short layer, short mode);
+
+	/**
+	 * Sets the start and end times of the action on the given layer
+	 */
+	void SetTimes(short layer, float start, float end);
+
+	/**
+	 * Stop playing the action on the given layer
+	 */
+	void StopAction(short layer);
+
+	/**
+	 * Check if an action has finished playing
+	 */
+	bool IsActionDone(short layer);
+
+	/**
+	 * Kick the object's action manager
+	 */
+	void UpdateActionManager(float curtime);
+
+	/*********************************
+	 * End Animation API
+	 *********************************/
+
 	/**
 	 * Construct a game object. This class also inherits the 
 	 * default constructors - use those with care!
@@ -866,6 +936,12 @@ public:
 	KX_PYMETHOD_DOC_O(KX_GameObject,getVectTo);
 	KX_PYMETHOD_DOC_VARARGS(KX_GameObject, sendMessage);
 	KX_PYMETHOD_VARARGS(KX_GameObject, ReinstancePhysicsMesh);
+
+	KX_PYMETHOD_DOC(KX_GameObject, playAction);
+	KX_PYMETHOD_DOC(KX_GameObject, stopAction);
+	KX_PYMETHOD_DOC(KX_GameObject, getActionFrame);
+	KX_PYMETHOD_DOC(KX_GameObject, setActionFrame);
+	KX_PYMETHOD_DOC(KX_GameObject, isPlayingAction);
 	
 	/* Dict access */
 	KX_PYMETHOD_VARARGS(KX_GameObject,get);
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
index eef543e629c..db919b7bc5a 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
@@ -68,7 +68,10 @@
 #include "KX_PyConstraintBinding.h"
 #include "PHY_IPhysicsEnvironment.h"
 
-#include "AUD_C-API.h"
+#ifdef WITH_AUDASPACE
+#  include "AUD_C-API.h"
+#  include "AUD_I3DDevice.h"
+#endif
 
 #include "NG_NetworkScene.h"
 #include "NG_NetworkDeviceInterface.h"
@@ -91,10 +94,10 @@
 
 const char KX_KetsjiEngine::m_profileLabels[tc_numCategories][15] = {
 	"Physics:",		// tc_physics
-	"Logic",		// tc_logic
+	"Logic:",		// tc_logic
+	"Animations:",	// tc_animations
 	"Network:",		// tc_network
 	"Scenegraph:",	// tc_scenegraph
-	"Sound:",		// tc_sound
 	"Rasterizer:",	// tc_rasterizer
 	"Services:",	// tc_services
 	"Overhead:",	// tc_overhead
@@ -108,13 +111,14 @@ double KX_KetsjiEngine::m_anim_framerate = 25.0;
 double KX_KetsjiEngine::m_suspendedtime = 0.0;
 double KX_KetsjiEngine::m_suspendeddelta = 0.0;
 double KX_KetsjiEngine::m_average_framerate = 0.0;
+bool   KX_KetsjiEngine::m_restrict_anim_fps = false;
 
 
 /**
  *	Constructor of the Ketsji Engine
  */
 KX_KetsjiEngine::KX_KetsjiEngine(KX_ISystem* system)
-     :	m_canvas(NULL),
+	:	m_canvas(NULL),
 	m_rasterizer(NULL),
 	m_kxsystem(system),
 	m_rendertools(NULL),
@@ -137,6 +141,7 @@ KX_KetsjiEngine::KX_KetsjiEngine(KX_ISystem* system)
 	m_frameTime(0.f),
 	m_clockTime(0.f),
 	m_previousClockTime(0.f),
+	m_previousAnimTime(0.f),
 
 
 	m_exitcode(KX_EXIT_REQUEST_NO_REQUEST),
@@ -578,7 +583,7 @@ else
 		framestep = (frames*timestep)/m_maxLogicFrame;
 		frames = m_maxLogicFrame;
 	}
-		
+
 	while (frames)
 	{
 	
@@ -657,7 +662,14 @@ else
 				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
 				SG_SetActiveStage(SG_STAGE_ACTUATOR_UPDATE);
 				scene->UpdateParents(m_frameTime);
-				
+
+				if (!GetRestrictAnimationFPS())
+				{
+					m_logger->StartLog(tc_animations, m_kxsystem->GetTimeInSeconds(), true);
+					SG_SetActiveStage(SG_STAGE_ANIMATION_UPDATE);
+					scene->UpdateAnimations(m_frameTime);
+				}
+
 				m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
 				SG_SetActiveStage(SG_STAGE_PHYSICS2);
 				scene->GetPhysicsEnvironment()->beginFrame();
@@ -681,8 +693,6 @@ else
 			else
 				if(scene->getSuspendedTime()==0.0)
 					scene->setSuspendedTime(m_clockTime);
-	
-			DoSound(scene);
 			
 			m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
 		}
@@ -758,14 +768,30 @@ else
  				if(scene->getSuspendedTime()==0.0)
  					scene->setSuspendedTime(m_clockTime);
 
-			DoSound(scene);
-
 			m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
 		}
 	}
 
+		
+	// Handle the animations independently of the logic time step
+	if (GetRestrictAnimationFPS())
+	{
+		m_logger->StartLog(tc_animations, m_kxsystem->GetTimeInSeconds(), true);
+		SG_SetActiveStage(SG_STAGE_ANIMATION_UPDATE);
 
-	m_previousClockTime = m_clockTime;
+		double anim_timestep = 1.0/KX_GetActiveScene()->GetAnimationFPS();
+		if (m_clockTime - m_previousAnimTime > anim_timestep)
+		{
+			// Sanity/debug print to make sure we're actually going at the fps we want (should be close to anim_timestep)
+			// printf("Anim fps: %f\n", 1.0/(m_clockTime - m_previousAnimTime));
+			m_previousAnimTime = m_clockTime;
+			for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
+			{
+				(*sceneit)->UpdateAnimations(m_frameTime);
+			}
+		}
+		m_previousClockTime = m_clockTime;
+	}
 	
 	// Start logging time spend outside main loop
 	m_logger->StartLog(tc_outside, m_kxsystem->GetTimeInSeconds(), true);
@@ -974,29 +1000,6 @@ const STR_String& KX_KetsjiEngine::GetExitString()
 }
 
 
-
-void KX_KetsjiEngine::DoSound(KX_Scene* scene)
-{
-	m_logger->StartLog(tc_sound, m_kxsystem->GetTimeInSeconds(), true);
-
-	KX_Camera* cam = scene->GetActiveCamera();
-	if (!cam)
-		return;
-
-	float f[4];
-
-	cam->NodeGetWorldPosition().getValue(f);
-	AUD_setListenerLocation(f);
-
-	cam->GetLinearVelocity().getValue(f);
-	AUD_setListenerVelocity(f);
-
-	cam->NodeGetWorldOrientation().getRotation().getValue(f);
-	AUD_setListenerOrientation(f);
-}
-
-
-
 void KX_KetsjiEngine::SetBackGround(KX_WorldInfo* wi)
 {
 	if (wi->hasWorld())
@@ -1220,7 +1223,7 @@ void KX_KetsjiEngine::RenderFrame(KX_Scene* scene, KX_Camera* cam)
 			projmat.setValue(m_overrideCamProjMat.getPointer());
 			cam->SetProjectionMatrix(projmat);
 		}
-	} else if (cam->hasValidProjectionMatrix() && !cam->GetViewport() )
+	} else if (cam->hasValidProjectionMatrix())
 	{
 		m_rasterizer->SetProjectionMatrix(cam->GetProjectionMatrix());
 	} else
@@ -1334,6 +1337,9 @@ To run once per scene
 */
 void KX_KetsjiEngine::PostRenderScene(KX_Scene* scene)
 {
+	// We need to first make sure our viewport is correct (enabling multiple viewports can mess this up)
+	m_canvas->SetViewPort(0, 0, m_canvas->GetWidth(), m_canvas->GetHeight());
+
 	m_rendertools->MotionBlur(m_rasterizer);
 	scene->Render2DFilters(m_canvas);
 #ifdef WITH_PYTHON
@@ -1799,6 +1805,16 @@ void KX_KetsjiEngine::SetMaxPhysicsFrame(int frame)
 	m_maxPhysicsFrame = frame;
 }
 
+bool KX_KetsjiEngine::GetRestrictAnimationFPS()
+{
+	return m_restrict_anim_fps;
+}
+
+void KX_KetsjiEngine::SetRestrictAnimationFPS(bool bRestrictAnimFPS)
+{
+	m_restrict_anim_fps = bRestrictAnimFPS;
+}
+
 double KX_KetsjiEngine::GetAnimFrameRate()
 {
 	return m_anim_framerate;
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.h b/source/gameengine/Ketsji/KX_KetsjiEngine.h
index 8cd6fdb8f5f..b1009c7d8f0 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.h
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.h
@@ -108,6 +108,7 @@ private:
 	double				m_frameTime;//discrete timestamp of the 'game logic frame'
 	double				m_clockTime;//current time
 	double				m_previousClockTime;//previous clock time
+	double				m_previousAnimTime; //the last time animations were updated
 	double				m_remainingTime;
 
 	static int				m_maxLogicFrame;	/* maximum number of consecutive logic frame */
@@ -115,6 +116,8 @@ private:
 	static double			m_ticrate;
 	static double			m_anim_framerate; /* for animation playback only - ipo and action */
 
+	static bool				m_restrict_anim_fps;
+
 	static double			m_suspendedtime;
 	static double			m_suspendeddelta;
 
@@ -147,9 +150,9 @@ private:
 		tc_first = 0,
 		tc_physics = 0,
 		tc_logic,
+		tc_animations,
 		tc_network,
 		tc_scenegraph,
-		tc_sound,
 		tc_rasterizer,
 		tc_services,	// time spend in miscelaneous activities
 		tc_overhead,	// profile info drawing overhead
@@ -195,7 +198,6 @@ private:
 	void					RenderDebugProperties();
 	void					RenderShadowBuffers(KX_Scene *scene);
 	void					SetBackGround(KX_WorldInfo* worldinfo);
-	void					DoSound(KX_Scene* scene);
 	void					RenderFonts(KX_Scene* scene);
 
 public:
@@ -321,6 +323,16 @@ public:
 	static void SetMaxPhysicsFrame(int frame);
 
 	/**
+	 * Gets whether or not to lock animation updates to the animframerate
+	 */
+	static bool GetRestrictAnimationFPS();
+
+	/**
+	 * Sets whether or not to lock animation updates to the animframerate
+	 */
+	static void SetRestrictAnimationFPS(bool bRestrictAnimFPS);
+
+	/**
 	 * Gets the framerate for playing animations. (actions and ipos)
 	 */
 	static double GetAnimFrameRate();
diff --git a/source/gameengine/Ketsji/KX_Light.cpp b/source/gameengine/Ketsji/KX_Light.cpp
index 49f00e39110..2f2c45cd5cc 100644
--- a/source/gameengine/Ketsji/KX_Light.cpp
+++ b/source/gameengine/Ketsji/KX_Light.cpp
@@ -254,8 +254,12 @@ void KX_LightObject::BindShadowBuffer(RAS_IRasterizer *ras, KX_Camera *cam, MT_T
 	cam->NodeUpdateGS(0);
 
 	/* setup rasterizer transformations */
+	/* SetViewMatrix may use stereomode which we temporarily disable here */
+	RAS_IRasterizer::StereoMode stereomode = ras->GetStereoMode();
+	ras->SetStereoMode(RAS_IRasterizer::RAS_STEREO_NOSTEREO);
 	ras->SetProjectionMatrix(projectionmat);
 	ras->SetViewMatrix(modelviewmat, cam->NodeGetWorldOrientation(), cam->NodeGetWorldPosition(), cam->GetCameraData()->m_perspective);
+	ras->SetStereoMode(stereomode);
 }
 
 void KX_LightObject::UnbindShadowBuffer(RAS_IRasterizer *ras)
@@ -351,11 +355,11 @@ PyObject* KX_LightObject::pyattr_get_typeconst(void *self_v, const KX_PYATTRIBUT
 	} else if (!strcmp(type, "NORMAL")) {
 		retvalue = PyLong_FromSsize_t(RAS_LightObject::LIGHT_NORMAL);
 	}
-    else {
-        /* should never happen */
-        PyErr_SetString(PyExc_TypeError, "light.type: internal error, invalid light type");
-        retvalue = NULL;
-    }
+	else {
+		/* should never happen */
+		PyErr_SetString(PyExc_TypeError, "light.type: internal error, invalid light type");
+		retvalue = NULL;
+	}
 
 	return retvalue;
 }
diff --git a/source/gameengine/Ketsji/KX_MeshProxy.cpp b/source/gameengine/Ketsji/KX_MeshProxy.cpp
index ba41dc355f7..9ad09f9793b 100644
--- a/source/gameengine/Ketsji/KX_MeshProxy.cpp
+++ b/source/gameengine/Ketsji/KX_MeshProxy.cpp
@@ -119,7 +119,7 @@ CValue*		KX_MeshProxy::GetReplica() { return NULL;}
 
 PyObject* KX_MeshProxy::PyGetMaterialName(PyObject* args, PyObject* kwds)
 {
-    int matid= 1;
+	int matid= 1;
 	STR_String matname;
 
 	if (PyArg_ParseTuple(args,"i:getMaterialName",&matid))
@@ -131,13 +131,13 @@ PyObject* KX_MeshProxy::PyGetMaterialName(PyObject* args, PyObject* kwds)
 	}
 
 	return PyUnicode_FromString(matname.Ptr());
-		
+
 }
-	
+
 
 PyObject* KX_MeshProxy::PyGetTextureName(PyObject* args, PyObject* kwds)
 {
-    int matid= 1;
+	int matid= 1;
 	STR_String matname;
 
 	if (PyArg_ParseTuple(args,"i:getTextureName",&matid))
@@ -154,7 +154,7 @@ PyObject* KX_MeshProxy::PyGetTextureName(PyObject* args, PyObject* kwds)
 
 PyObject* KX_MeshProxy::PyGetVertexArrayLength(PyObject* args, PyObject* kwds)
 {
-    int matid= 0;
+	int matid= 0;
 	int length = 0;
 
 	
@@ -177,7 +177,7 @@ PyObject* KX_MeshProxy::PyGetVertexArrayLength(PyObject* args, PyObject* kwds)
 
 PyObject* KX_MeshProxy::PyGetVertex(PyObject* args, PyObject* kwds)
 {
-    int vertexindex;
+	int vertexindex;
 	int matindex;
 
 	if (!PyArg_ParseTuple(args,"ii:getVertex",&matindex,&vertexindex))
@@ -195,7 +195,7 @@ PyObject* KX_MeshProxy::PyGetVertex(PyObject* args, PyObject* kwds)
 
 PyObject* KX_MeshProxy::PyGetPolygon(PyObject* args, PyObject* kwds)
 {
-    int polyindex= 1;
+	int polyindex= 1;
 	PyObject* polyob = NULL;
 
 	if (!PyArg_ParseTuple(args,"i:getPolygon",&polyindex))
diff --git a/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp b/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp
index 6cb80028858..34f5c26415d 100644
--- a/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp
+++ b/source/gameengine/Ketsji/KX_MouseFocusSensor.cpp
@@ -121,14 +121,14 @@ bool KX_MouseFocusSensor::Evaluate()
 			}
 		} 
 		if (reset) {
-			// force an event 
+			// force an event
 			result = true;
 		}
 	} else {
 		/* No focus behaviour required: revert to the basic mode. This
-         * mode is never used, because the converter never makes this
-         * sensor for a mouse-key event. It is here for
-         * completeness. */
+		 * mode is never used, because the converter never makes this
+		 * sensor for a mouse-key event. It is here for
+		 * completeness. */
 		result = SCA_MouseSensor::Evaluate();
 		m_positive_event = (m_val!=0);
 	}
diff --git a/source/gameengine/Ketsji/KX_ObjectActuator.cpp b/source/gameengine/Ketsji/KX_ObjectActuator.cpp
index 7289ffc6e29..cb59ef42699 100644
--- a/source/gameengine/Ketsji/KX_ObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ObjectActuator.cpp
@@ -237,9 +237,9 @@ bool KX_ObjectActuator::Update()
 						if (m_current_linear_factor > 1.0)
 							m_current_linear_factor = 1.0;
 						linV = m_current_linear_factor * m_linear_velocity;
-	 					parent->setLinearVelocity(linV,(m_bitLocalFlag.LinearVelocity) != 0);
+						parent->setLinearVelocity(linV,(m_bitLocalFlag.LinearVelocity) != 0);
 					} else {
-	 					parent->setLinearVelocity(m_linear_velocity,(m_bitLocalFlag.LinearVelocity) != 0);
+						parent->setLinearVelocity(m_linear_velocity,(m_bitLocalFlag.LinearVelocity) != 0);
 					}
 				}
 			}
@@ -260,7 +260,7 @@ bool KX_ObjectActuator::Update()
 					if (m_current_angular_factor > 1.0)
 						m_current_angular_factor = 1.0;
 					angV = m_current_angular_factor * m_angular_velocity;
-	 				parent->setAngularVelocity(angV,(m_bitLocalFlag.AngularVelocity) != 0);
+					parent->setAngularVelocity(angV,(m_bitLocalFlag.AngularVelocity) != 0);
 				} else {
 					parent->setAngularVelocity(m_angular_velocity,(m_bitLocalFlag.AngularVelocity) != 0);
 				}
diff --git a/source/gameengine/Ketsji/KX_OrientationInterpolator.cpp b/source/gameengine/Ketsji/KX_OrientationInterpolator.cpp
index d9483083aa1..bd743159950 100644
--- a/source/gameengine/Ketsji/KX_OrientationInterpolator.cpp
+++ b/source/gameengine/Ketsji/KX_OrientationInterpolator.cpp
@@ -51,6 +51,6 @@ void KX_OrientationInterpolator::Execute(float currentTime) const {
 	MT_Scalar ss = si*sh;
 
 	m_target.setValue(cj*ch, sj*sc-cs, sj*cc+ss,
-					  cj*sh, sj*ss+cc, sj*cs-sc, 
-					    -sj,    cj*si,    cj*ci);
+	                  cj*sh, sj*ss+cc, sj*cs-sc,
+	                  -sj,    cj*si,    cj*ci);
 }
diff --git a/source/gameengine/Ketsji/KX_PolygonMaterial.cpp b/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
index 9d0597051ad..d32f267f0e0 100644
--- a/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
@@ -187,7 +187,7 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
 			rasty->SetCullFace(true);
 
 		if ((m_drawingmode & RAS_IRasterizer::KX_LINES) ||
-		    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
+		        (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
 			rasty->SetLines(true);
 		else
 			rasty->SetLines(false);
diff --git a/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp b/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
index 12024657149..fde127b7ef5 100644
--- a/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
+++ b/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
@@ -38,12 +38,20 @@
 #include "KX_PhysicsObjectWrapper.h"
 #include "PHY_IPhysicsController.h"
 #include "PHY_IVehicle.h"
+#include "PHY_DynamicTypes.h"
 #include "MT_Matrix3x3.h"
 
 #include "PyObjectPlus.h" 
 
+#ifdef USE_BULLET
+#  include "LinearMath/btIDebugDraw.h"
+#endif
+
 #ifdef WITH_PYTHON
 
+// macro copied from KX_PythonInit.cpp
+#define KX_MACRO_addTypesToDict(dict, name, name2) PyDict_SetItemString(dict, #name, item=PyLong_FromSsize_t(name2)); Py_DECREF(item)
+
 // nasty glob variable to connect scripting language
 // if there is a better way (without global), please do so!
 static PHY_IPhysicsEnvironment* g_CurrentActivePhysicsEnvironment = NULL;
@@ -84,8 +92,8 @@ static char gPyGetAppliedImpulse__doc__[] = "getAppliedImpulse(int constraintId)
 
 
 static PyObject* gPySetGravity(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                               PyObject* args,
+                               PyObject* kwds)
 {
 	float x,y,z;
 	if (PyArg_ParseTuple(args,"fff",&x,&y,&z))
@@ -101,8 +109,8 @@ static PyObject* gPySetGravity(PyObject* self,
 }
 
 static PyObject* gPySetDebugMode(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                 PyObject* args,
+                                 PyObject* kwds)
 {
 	int mode;
 	if (PyArg_ParseTuple(args,"i",&mode))
@@ -124,8 +132,8 @@ static PyObject* gPySetDebugMode(PyObject* self,
 
 
 static PyObject* gPySetNumTimeSubSteps(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                       PyObject* args,
+                                       PyObject* kwds)
 {
 	int substep;
 	if (PyArg_ParseTuple(args,"i",&substep))
@@ -143,8 +151,8 @@ static PyObject* gPySetNumTimeSubSteps(PyObject* self,
 
 
 static PyObject* gPySetNumIterations(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
 	int iter;
 	if (PyArg_ParseTuple(args,"i",&iter))
@@ -161,10 +169,9 @@ static PyObject* gPySetNumIterations(PyObject* self,
 }
 
 
-
 static PyObject* gPySetDeactivationTime(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                        PyObject* args,
+                                        PyObject* kwds)
 {
 	float deactive_time;
 	if (PyArg_ParseTuple(args,"f",&deactive_time))
@@ -182,8 +189,8 @@ static PyObject* gPySetDeactivationTime(PyObject* self,
 
 
 static PyObject* gPySetDeactivationLinearTreshold(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                                  PyObject* args,
+                                                  PyObject* kwds)
 {
 	float linearDeactivationTreshold;
 	if (PyArg_ParseTuple(args,"f",&linearDeactivationTreshold))
@@ -201,8 +208,8 @@ static PyObject* gPySetDeactivationLinearTreshold(PyObject* self,
 
 
 static PyObject* gPySetDeactivationAngularTreshold(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                                   PyObject* args,
+                                                   PyObject* kwds)
 {
 	float angularDeactivationTreshold;
 	if (PyArg_ParseTuple(args,"f",&angularDeactivationTreshold))
@@ -219,8 +226,8 @@ static PyObject* gPySetDeactivationAngularTreshold(PyObject* self,
 }
 
 static PyObject* gPySetContactBreakingTreshold(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                               PyObject* args,
+                                               PyObject* kwds)
 {
 	float contactBreakingTreshold;
 	if (PyArg_ParseTuple(args,"f",&contactBreakingTreshold))
@@ -238,8 +245,8 @@ static PyObject* gPySetContactBreakingTreshold(PyObject* self,
 
 
 static PyObject* gPySetCcdMode(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                               PyObject* args,
+                               PyObject* kwds)
 {
 	float ccdMode;
 	if (PyArg_ParseTuple(args,"f",&ccdMode))
@@ -256,8 +263,8 @@ static PyObject* gPySetCcdMode(PyObject* self,
 }
 
 static PyObject* gPySetSorConstant(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                   PyObject* args,
+                                   PyObject* kwds)
 {
 	float sor;
 	if (PyArg_ParseTuple(args,"f",&sor))
@@ -274,8 +281,8 @@ static PyObject* gPySetSorConstant(PyObject* self,
 }
 
 static PyObject* gPySetSolverTau(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                 PyObject* args,
+                                 PyObject* kwds)
 {
 	float tau;
 	if (PyArg_ParseTuple(args,"f",&tau))
@@ -293,8 +300,8 @@ static PyObject* gPySetSolverTau(PyObject* self,
 
 
 static PyObject* gPySetSolverDamping(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
 	float damping;
 	if (PyArg_ParseTuple(args,"f",&damping))
@@ -311,8 +318,8 @@ static PyObject* gPySetSolverDamping(PyObject* self,
 }
 
 static PyObject* gPySetLinearAirDamping(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                        PyObject* args,
+                                        PyObject* kwds)
 {
 	float damping;
 	if (PyArg_ParseTuple(args,"f",&damping))
@@ -330,8 +337,8 @@ static PyObject* gPySetLinearAirDamping(PyObject* self,
 
 
 static PyObject* gPySetUseEpa(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                              PyObject* args,
+                              PyObject* kwds)
 {
 	int	epa;
 	if (PyArg_ParseTuple(args,"i",&epa))
@@ -347,8 +354,8 @@ static PyObject* gPySetUseEpa(PyObject* self,
 	Py_RETURN_NONE;
 }
 static PyObject* gPySetSolverType(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                  PyObject* args,
+                                  PyObject* kwds)
 {
 	int	solverType;
 	if (PyArg_ParseTuple(args,"i",&solverType))
@@ -367,8 +374,8 @@ static PyObject* gPySetSolverType(PyObject* self,
 
 
 static PyObject* gPyGetVehicleConstraint(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                         PyObject* args,
+                                         PyObject* kwds)
 {
 #if defined(_WIN64)
 	__int64 constraintid;
@@ -398,9 +405,6 @@ static PyObject* gPyGetVehicleConstraint(PyObject* self,
 }
 
 
-
-
-
 static PyObject* gPyCreateConstraint(PyObject* self,
 										 PyObject* args, 
 										 PyObject* kwds)
@@ -425,39 +429,39 @@ static PyObject* gPyCreateConstraint(PyObject* self,
 		success = PyArg_ParseTuple(args,"lli",&physicsid,&physicsid2,&constrainttype);
 #endif
 	}
-	else
-	if (len ==6)
+	else if (len == 6)
 	{
 #if defined(_WIN64)
 		success = PyArg_ParseTuple(args,"LLifff",&physicsid,&physicsid2,&constrainttype,
-			&pivotX,&pivotY,&pivotZ);
+		                           &pivotX,&pivotY,&pivotZ);
 #else
 		success = PyArg_ParseTuple(args,"llifff",&physicsid,&physicsid2,&constrainttype,
-								   &pivotX,&pivotY,&pivotZ);		
+		                           &pivotX,&pivotY,&pivotZ);
 #endif	
 	}
 	else if (len == 9)
 	{
 #if defined(_WIN64)
 		success = PyArg_ParseTuple(args,"LLiffffff",&physicsid,&physicsid2,&constrainttype,
-			&pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
+		                           &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
 #else
 		success = PyArg_ParseTuple(args,"lliffffff",&physicsid,&physicsid2,&constrainttype,
-								   &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
+		                           &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
 #endif
-	
 	}
 	else if (len == 10)
 	{
 #if defined(_WIN64)
 		success = PyArg_ParseTuple(args,"LLiffffffi",&physicsid,&physicsid2,&constrainttype,
-			&pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
+		                           &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
 #else
 		success = PyArg_ParseTuple(args,"lliffffffi",&physicsid,&physicsid2,&constrainttype,
-								   &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
+		                           &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
 #endif
 	}
-	else if (len==4)
+
+	/* XXX extrainfo seems to be nothing implemented. right now it works as a pivot with [X,0,0] */
+	else if (len == 4)
 	{
 #if defined(_WIN64)
 		success = PyArg_ParseTuple(args,"LLii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
@@ -466,7 +470,7 @@ static PyObject* gPyCreateConstraint(PyObject* self,
 #endif
 		pivotX=extrainfo;
 	}
-	
+
 	if (success)
 	{
 		if (PHY_GetActiveEnvironment())
@@ -490,20 +494,18 @@ static PyObject* gPyCreateConstraint(PyObject* self,
 					MT_Vector3 axis0 = localCFrame.getColumn(0);
 					MT_Vector3 axis1 = localCFrame.getColumn(1);
 					MT_Vector3 axis2 = localCFrame.getColumn(2);
-						
-					constraintid = PHY_GetActiveEnvironment()->createConstraint(physctrl,physctrl2,(enum PHY_ConstraintType)constrainttype,
-						pivotX,pivotY,pivotZ,
-						(float)axis0.x(),(float)axis0.y(),(float)axis0.z(),
-						(float)axis1.x(),(float)axis1.y(),(float)axis1.z(),
-						(float)axis2.x(),(float)axis2.y(),(float)axis2.z(),flag);
 
-				} else
-				{
+					constraintid = PHY_GetActiveEnvironment()->createConstraint(physctrl,physctrl2,(enum PHY_ConstraintType)constrainttype,
+					                                                            pivotX,pivotY,pivotZ,
+					                                                            (float)axis0.x(),(float)axis0.y(),(float)axis0.z(),
+					                                                            (float)axis1.x(),(float)axis1.y(),(float)axis1.z(),
+					                                                            (float)axis2.x(),(float)axis2.y(),(float)axis2.z(),flag);
+				}
+				else {
 					constraintid = PHY_GetActiveEnvironment()->createConstraint(physctrl,physctrl2,(enum PHY_ConstraintType)constrainttype,pivotX,pivotY,pivotZ,axisX,axisY,axisZ,0);
 				}
 				
 				KX_ConstraintWrapper* wrap = new KX_ConstraintWrapper((enum PHY_ConstraintType)constrainttype,constraintid,PHY_GetActiveEnvironment());
-				
 
 				return wrap->NewProxy(true);
 			}
@@ -522,8 +524,8 @@ static PyObject* gPyCreateConstraint(PyObject* self,
 
 
 static PyObject* gPyGetAppliedImpulse(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                      PyObject* args,
+                                      PyObject* kwds)
 {
 	float	appliedImpulse = 0.f;
 
@@ -549,8 +551,8 @@ static PyObject* gPyGetAppliedImpulse(PyObject* self,
 
 
 static PyObject* gPyRemoveConstraint(PyObject* self,
-										 PyObject* args, 
-										 PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
 #if defined(_WIN64)
 	__int64 constraintid;
@@ -577,7 +579,7 @@ static PyObject* gPyExportBulletFile(PyObject*, PyObject* args)
 	char* filename;
 	if (!PyArg_ParseTuple(args,"s:exportBulletFile",&filename))
 		return NULL;
-		
+
 	if (PHY_GetActiveEnvironment())
 	{
 		PHY_GetActiveEnvironment()->exportFile(filename);
@@ -586,62 +588,61 @@ static PyObject* gPyExportBulletFile(PyObject*, PyObject* args)
 }
 
 static struct PyMethodDef physicsconstraints_methods[] = {
-  {"setGravity",(PyCFunction) gPySetGravity,
-   METH_VARARGS, (const char *)gPySetGravity__doc__},
-  {"setDebugMode",(PyCFunction) gPySetDebugMode,
-   METH_VARARGS, (const char *)gPySetDebugMode__doc__},
-
-   /// settings that influence quality of the rigidbody dynamics
-  {"setNumIterations",(PyCFunction) gPySetNumIterations,
-   METH_VARARGS, (const char *)gPySetNumIterations__doc__},
-
-   {"setNumTimeSubSteps",(PyCFunction) gPySetNumTimeSubSteps,
-   METH_VARARGS, (const char *)gPySetNumTimeSubSteps__doc__},
-
-  {"setDeactivationTime",(PyCFunction) gPySetDeactivationTime,
-   METH_VARARGS, (const char *)gPySetDeactivationTime__doc__},
-
-  {"setDeactivationLinearTreshold",(PyCFunction) gPySetDeactivationLinearTreshold,
-   METH_VARARGS, (const char *)gPySetDeactivationLinearTreshold__doc__},
-  {"setDeactivationAngularTreshold",(PyCFunction) gPySetDeactivationAngularTreshold,
-   METH_VARARGS, (const char *)gPySetDeactivationAngularTreshold__doc__},
-
-   {"setContactBreakingTreshold",(PyCFunction) gPySetContactBreakingTreshold,
-   METH_VARARGS, (const char *)gPySetContactBreakingTreshold__doc__},
-     {"setCcdMode",(PyCFunction) gPySetCcdMode,
-   METH_VARARGS, (const char *)gPySetCcdMode__doc__},
-     {"setSorConstant",(PyCFunction) gPySetSorConstant,
-   METH_VARARGS, (const char *)gPySetSorConstant__doc__},
-       {"setSolverTau",(PyCFunction) gPySetSolverTau,
-   METH_VARARGS, (const char *)gPySetSolverTau__doc__},
-        {"setSolverDamping",(PyCFunction) gPySetSolverDamping,
-   METH_VARARGS, (const char *)gPySetSolverDamping__doc__},
-
-         {"setLinearAirDamping",(PyCFunction) gPySetLinearAirDamping,
-   METH_VARARGS, (const char *)gPySetLinearAirDamping__doc__},
-
-    {"setUseEpa",(PyCFunction) gPySetUseEpa,
-   METH_VARARGS, (const char *)gPySetUseEpa__doc__},
+	{"setGravity",(PyCFunction) gPySetGravity,
+	 METH_VARARGS, (const char*)gPySetGravity__doc__},
+	{"setDebugMode",(PyCFunction) gPySetDebugMode,
+	 METH_VARARGS, (const char *)gPySetDebugMode__doc__},
+
+	/// settings that influence quality of the rigidbody dynamics
+	{"setNumIterations",(PyCFunction) gPySetNumIterations,
+	 METH_VARARGS, (const char *)gPySetNumIterations__doc__},
+
+	{"setNumTimeSubSteps",(PyCFunction) gPySetNumTimeSubSteps,
+	 METH_VARARGS, (const char *)gPySetNumTimeSubSteps__doc__},
+
+	{"setDeactivationTime",(PyCFunction) gPySetDeactivationTime,
+	 METH_VARARGS, (const char *)gPySetDeactivationTime__doc__},
+
+	{"setDeactivationLinearTreshold",(PyCFunction) gPySetDeactivationLinearTreshold,
+	 METH_VARARGS, (const char *)gPySetDeactivationLinearTreshold__doc__},
+	{"setDeactivationAngularTreshold",(PyCFunction) gPySetDeactivationAngularTreshold,
+	 METH_VARARGS, (const char *)gPySetDeactivationAngularTreshold__doc__},
+
+	{"setContactBreakingTreshold",(PyCFunction) gPySetContactBreakingTreshold,
+	 METH_VARARGS, (const char *)gPySetContactBreakingTreshold__doc__},
+	{"setCcdMode",(PyCFunction) gPySetCcdMode,
+	 METH_VARARGS, (const char *)gPySetCcdMode__doc__},
+	{"setSorConstant",(PyCFunction) gPySetSorConstant,
+	 METH_VARARGS, (const char *)gPySetSorConstant__doc__},
+	{"setSolverTau",(PyCFunction) gPySetSolverTau,
+	 METH_VARARGS, (const char *)gPySetSolverTau__doc__},
+	{"setSolverDamping",(PyCFunction) gPySetSolverDamping,
+	 METH_VARARGS, (const char *)gPySetSolverDamping__doc__},
+
+	{"setLinearAirDamping",(PyCFunction) gPySetLinearAirDamping,
+	 METH_VARARGS, (const char *)gPySetLinearAirDamping__doc__},
+
+	{"setUseEpa",(PyCFunction) gPySetUseEpa,
+	 METH_VARARGS, (const char *)gPySetUseEpa__doc__},
 	{"setSolverType",(PyCFunction) gPySetSolverType,
-   METH_VARARGS, (const char *)gPySetSolverType__doc__},
+	 METH_VARARGS, (const char *)gPySetSolverType__doc__},
 
 
-  {"createConstraint",(PyCFunction) gPyCreateConstraint,
-   METH_VARARGS, (const char *)gPyCreateConstraint__doc__},
-     {"getVehicleConstraint",(PyCFunction) gPyGetVehicleConstraint,
-   METH_VARARGS, (const char *)gPyGetVehicleConstraint__doc__},
+	{"createConstraint",(PyCFunction) gPyCreateConstraint,
+	 METH_VARARGS, (const char *)gPyCreateConstraint__doc__},
+	{"getVehicleConstraint",(PyCFunction) gPyGetVehicleConstraint,
+	 METH_VARARGS, (const char *)gPyGetVehicleConstraint__doc__},
 
-  {"removeConstraint",(PyCFunction) gPyRemoveConstraint,
-   METH_VARARGS, (const char *)gPyRemoveConstraint__doc__},
+	{"removeConstraint",(PyCFunction) gPyRemoveConstraint,
+	 METH_VARARGS, (const char *)gPyRemoveConstraint__doc__},
 	{"getAppliedImpulse",(PyCFunction) gPyGetAppliedImpulse,
-   METH_VARARGS, (const char *)gPyGetAppliedImpulse__doc__},
+	 METH_VARARGS, (const char *)gPyGetAppliedImpulse__doc__},
 
-     {"exportBulletFile",(PyCFunction)gPyExportBulletFile,
-	METH_VARARGS, "export a .bullet file"},
+	{"exportBulletFile",(PyCFunction)gPyExportBulletFile,
+	 METH_VARARGS, "export a .bullet file"},
 
-
-   //sentinel
-  { NULL, (PyCFunction) NULL, 0, NULL }
+	//sentinel
+	{ NULL, (PyCFunction) NULL, 0, NULL }
 };
 
 static struct PyModuleDef PhysicsConstraints_module_def = {
@@ -656,12 +657,13 @@ static struct PyModuleDef PhysicsConstraints_module_def = {
 	0,  /* m_free */
 };
 
-PyObject*	initPythonConstraintBinding()
+PyObject* initPythonConstraintBinding()
 {
 
-  PyObject* ErrorObject;
-  PyObject* m;
-  PyObject* d;
+	PyObject* ErrorObject;
+	PyObject* m;
+	PyObject* d;
+	PyObject* item;
 
 	/* Use existing module where possible
 	 * be careful not to init any runtime vars after this */
@@ -677,21 +679,43 @@ PyObject*	initPythonConstraintBinding()
 		PyDict_SetItemString(PySys_GetObject("modules"), PhysicsConstraints_module_def.m_name, m);
 	}
 
-  // Add some symbolic constants to the module
-  d = PyModule_GetDict(m);
-  ErrorObject = PyUnicode_FromString("PhysicsConstraints.error");
-  PyDict_SetItemString(d, "error", ErrorObject);
-  Py_DECREF(ErrorObject);
-
-  // XXXX Add constants here
-
-  // Check for errors
-  if (PyErr_Occurred())
-    {
-      Py_FatalError("can't initialize module PhysicsConstraints");
-    }
-
-  return d;
+	// Add some symbolic constants to the module
+	d = PyModule_GetDict(m);
+	ErrorObject = PyUnicode_FromString("PhysicsConstraints.error");
+	PyDict_SetItemString(d, "error", ErrorObject);
+	Py_DECREF(ErrorObject);
+
+#ifdef USE_BULLET
+	//Debug Modes constants to be used with setDebugMode() python function
+	KX_MACRO_addTypesToDict(d, DBG_NODEBUG, btIDebugDraw::DBG_NoDebug);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWWIREFRAME, btIDebugDraw::DBG_DrawWireframe);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWAABB, btIDebugDraw::DBG_DrawAabb);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWFREATURESTEXT, btIDebugDraw::DBG_DrawFeaturesText);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWCONTACTPOINTS, btIDebugDraw::DBG_DrawContactPoints);
+	KX_MACRO_addTypesToDict(d, DBG_NOHELPTEXT, btIDebugDraw::DBG_NoHelpText);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWTEXT, btIDebugDraw::DBG_DrawText);
+	KX_MACRO_addTypesToDict(d, DBG_PROFILETIMINGS, btIDebugDraw::DBG_ProfileTimings);
+	KX_MACRO_addTypesToDict(d, DBG_ENABLESATCOMPARISION, btIDebugDraw::DBG_EnableSatComparison);
+	KX_MACRO_addTypesToDict(d, DBG_DISABLEBULLETLCP, btIDebugDraw::DBG_DisableBulletLCP);
+	KX_MACRO_addTypesToDict(d, DBG_ENABLECDD, btIDebugDraw::DBG_EnableCCD);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTS, btIDebugDraw::DBG_DrawConstraints);
+	KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTLIMITS, btIDebugDraw::DBG_DrawConstraintLimits);
+	KX_MACRO_addTypesToDict(d, DBG_FASTWIREFRAME, btIDebugDraw::DBG_FastWireframe);
+#endif // USE_BULLET
+
+	//Constraint types to be used with createConstraint() python function
+	KX_MACRO_addTypesToDict(d, POINTTOPOINT_CONSTRAINT, PHY_POINT2POINT_CONSTRAINT);
+	KX_MACRO_addTypesToDict(d, LINEHINGE_CONSTRAINT, PHY_LINEHINGE_CONSTRAINT);
+	KX_MACRO_addTypesToDict(d, ANGULAR_CONSTRAINT, PHY_ANGULAR_CONSTRAINT);
+	KX_MACRO_addTypesToDict(d, CONETWIST_CONSTRAINT, PHY_CONE_TWIST_CONSTRAINT);
+	KX_MACRO_addTypesToDict(d, VEHICLE_CONSTRAINT, PHY_VEHICLE_CONSTRAINT);
+
+	// Check for errors
+	if (PyErr_Occurred()) {
+		Py_FatalError("can't initialize module PhysicsConstraints");
+	}
+
+	return d;
 }
 
 
@@ -709,7 +733,4 @@ PHY_IPhysicsEnvironment*	PHY_GetActiveEnvironment()
 	return g_CurrentActivePhysicsEnvironment;
 }
 
-
-
 #endif // WITH_PYTHON
-
diff --git a/source/gameengine/Ketsji/KX_PyMath.h b/source/gameengine/Ketsji/KX_PyMath.h
index 9b198f85664..4864482c33b 100644
--- a/source/gameengine/Ketsji/KX_PyMath.h
+++ b/source/gameengine/Ketsji/KX_PyMath.h
@@ -49,7 +49,7 @@
 #ifdef WITH_PYTHON
 #ifdef USE_MATHUTILS
 extern "C" {
-#include "../../blender/python/generic/mathutils.h" /* so we can have mathutils callbacks */
+#include "../../blender/python/mathutils/mathutils.h" /* so we can have mathutils callbacks */
 }
 #endif
 
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index f984538fa5b..fb39e944559 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -54,7 +54,7 @@
 extern "C" {
 	#include "bpy_internal_import.h"  /* from the blender python api, but we want to import text too! */
 	#include "py_capi_utils.h"
-	#include "mathutils.h" // Blender.Mathutils module copied here so the blenderlayer can use.
+	#include "mathutils.h" // 'mathutils' module copied here so the blenderlayer can use.
 	#include "bgl.h"
 	#include "blf_py_api.h"
 
@@ -115,6 +115,7 @@ extern "C" {
 #include "NG_NetworkScene.h" //Needed for sendMessage()
 
 #include "BL_Shader.h"
+#include "BL_Action.h"
 
 #include "KX_PyMath.h"
 
@@ -336,7 +337,7 @@ static PyObject* gPyLoadGlobalDict(PyObject*)
 {
 	char marshal_path[512];
 	char *marshal_buffer = NULL;
-	unsigned int marshal_length;
+	size_t marshal_length;
 	FILE *fp = NULL;
 	int result;
 
@@ -347,7 +348,7 @@ static PyObject* gPyLoadGlobalDict(PyObject*)
 	if (fp) {
 		// obtain file size:
 		fseek (fp, 0, SEEK_END);
-		marshal_length = ftell(fp);
+		marshal_length = (size_t)ftell(fp);
 		rewind(fp);
 
 		marshal_buffer = (char*)malloc (sizeof(char)*marshal_length);
@@ -397,10 +398,10 @@ static PyObject* gPyGetSpectrum(PyObject*)
 {
 	PyObject* resultlist = PyList_New(512);
 
-        for (int index = 0; index < 512; index++)
-        {
-                PyList_SET_ITEM(resultlist, index, PyFloat_FromDouble(0.0));
-        }
+	for (int index = 0; index < 512; index++)
+	{
+		PyList_SET_ITEM(resultlist, index, PyFloat_FromDouble(0.0));
+	}
 
 	return resultlist;
 }
@@ -487,13 +488,13 @@ static PyObject* gPyGetBlendFileList(PyObject*, PyObject* args)
 	char cpath[sizeof(gp_GamePythonPath)];
 	char *searchpath = NULL;
 	PyObject* list, *value;
-	
-    DIR *dp;
-    struct dirent *dirp;
-	
+
+	DIR *dp;
+	struct dirent *dirp;
+
 	if (!PyArg_ParseTuple(args, "|s:getBlendFileList", &searchpath))
 		return NULL;
-	
+
 	list = PyList_New(0);
 	
 	if (searchpath) {
@@ -503,23 +504,23 @@ static PyObject* gPyGetBlendFileList(PyObject*, PyObject* args)
 		/* Get the dir only */
 		BLI_split_dirfile(gp_GamePythonPath, cpath, NULL);
 	}
-	
-    if((dp  = opendir(cpath)) == NULL) {
+
+	if((dp  = opendir(cpath)) == NULL) {
 		/* todo, show the errno, this shouldnt happen anyway if the blendfile is readable */
 		fprintf(stderr, "Could not read directoty (%s) failed, code %d (%s)\n", cpath, errno, strerror(errno));
 		return list;
-    }
+	}
 	
-    while ((dirp = readdir(dp)) != NULL) {
+	while ((dirp = readdir(dp)) != NULL) {
 		if (BLI_testextensie(dirp->d_name, ".blend")) {
 			value= PyUnicode_DecodeFSDefault(dirp->d_name);
 			PyList_Append(list, value);
 			Py_DECREF(value);
 		}
-    }
+	}
 	
-    closedir(dp);
-    return list;
+	closedir(dp);
+	return list;
 }
 
 static char gPyAddScene_doc[] = 
@@ -1216,6 +1217,28 @@ static PyObject* gPyGetMaterialType(PyObject*)
 	return PyLong_FromSsize_t(flag);
 }
 
+static PyObject* gPySetAnisotropicFiltering(PyObject*, PyObject* args)
+{
+	short level;
+
+	if (!PyArg_ParseTuple(args, "h:setAnisotropicFiltering", &level))
+		return NULL;
+
+	if (level != 1 && level != 2 && level != 4 && level != 8 && level != 16) {
+		PyErr_SetString(PyExc_ValueError, "Rasterizer.setAnisotropicFiltering(level): Expected value of 1, 2, 4, 8, or 16 for value");
+		return NULL;
+	}
+
+	gp_Rasterizer->SetAnisotropicFiltering(level);
+
+	Py_RETURN_NONE;
+}
+
+static PyObject* gPyGetAnisotropicFiltering(PyObject*, PyObject* args)
+{
+	return PyLong_FromLong(gp_Rasterizer->GetAnisotropicFiltering());
+}
+
 static PyObject* gPyDrawLine(PyObject*, PyObject* args)
 {
 	PyObject* ob_from;
@@ -1280,6 +1303,10 @@ static struct PyMethodDef rasterizer_methods[] = {
    METH_VARARGS, "set the state of a GLSL material setting"},
   {"getGLSLMaterialSetting",(PyCFunction) gPyGetGLSLMaterialSetting,
    METH_VARARGS, "get the state of a GLSL material setting"},
+  {"setAnisotropicFiltering", (PyCFunction) gPySetAnisotropicFiltering,
+  METH_VARARGS, "set the anisotropic filtering level (must be one of 1, 2, 4, 8, 16)"},
+  {"getAnisotropicFiltering", (PyCFunction) gPyGetAnisotropicFiltering,
+  METH_VARARGS, "get the anisotropic filtering level"},
   {"drawLine", (PyCFunction) gPyDrawLine,
    METH_VARARGS, "draw a line on the screen"},
   { NULL, (PyCFunction) NULL, 0, NULL }
@@ -1647,11 +1674,16 @@ PyObject* initGameLogic(KX_KetsjiEngine *engine, KX_Scene* scene) // quick hack
 	KX_MACRO_addTypesToDict(d, RM_POLYS, KX_NavMeshObject::RM_POLYS);
 	KX_MACRO_addTypesToDict(d, RM_TRIS, KX_NavMeshObject::RM_TRIS);
 
+	/* BL_Action play modes */
+	KX_MACRO_addTypesToDict(d, KX_ACTION_MODE_PLAY, BL_Action::ACT_MODE_PLAY);
+	KX_MACRO_addTypesToDict(d, KX_ACTION_MODE_LOOP, BL_Action::ACT_MODE_LOOP);
+	KX_MACRO_addTypesToDict(d, KX_ACTION_MODE_PING_PONG, BL_Action::ACT_MODE_PING_PONG);
+
 	// Check for errors
 	if (PyErr_Occurred())
-    {
+	{
 		Py_FatalError("can't initialize module bge.logic");
-    }
+	}
 
 	return m;
 }
@@ -1768,7 +1800,7 @@ static void restorePySysObjects(void)
 
 // Copied from bpy_interface.c
 static struct _inittab bge_internal_modules[]= {
-	{(char *)"mathutils", BPyInit_mathutils},
+	{(char *)"mathutils", PyInit_mathutils},
 	{(char *)"bgl", BPyInit_bgl},
 	{(char *)"blf", BPyInit_blf},
 	{(char *)"aud", AUD_initPython},
@@ -1941,12 +1973,12 @@ PyObject* initRasterizer(RAS_IRasterizer* rasty,RAS_ICanvas* canvas)
 	gp_Rasterizer = rasty;
 
 
-  PyObject* m;
-  PyObject* d;
-  PyObject* item;
+	PyObject* m;
+	PyObject* d;
+	PyObject* item;
 
 	/* Use existing module where possible
-	 * be careful not to init any runtime vars after this */
+  * be careful not to init any runtime vars after this */
 	m = PyImport_ImportModule( "Rasterizer" );
 	if(m) {
 		Py_DECREF(m);
@@ -1954,32 +1986,32 @@ PyObject* initRasterizer(RAS_IRasterizer* rasty,RAS_ICanvas* canvas)
 	}
 	else {
 		PyErr_Clear();
-	
+
 		// Create the module and add the functions
 		m = PyModule_Create(&Rasterizer_module_def);
 		PyDict_SetItemString(PySys_GetObject("modules"), Rasterizer_module_def.m_name, m);
 	}
 
-  // Add some symbolic constants to the module
-  d = PyModule_GetDict(m);
-  ErrorObject = PyUnicode_FromString("Rasterizer.error");
-  PyDict_SetItemString(d, "error", ErrorObject);
-  Py_DECREF(ErrorObject);
+	// Add some symbolic constants to the module
+	d = PyModule_GetDict(m);
+	ErrorObject = PyUnicode_FromString("Rasterizer.error");
+	PyDict_SetItemString(d, "error", ErrorObject);
+	Py_DECREF(ErrorObject);
 
-  /* needed for get/setMaterialType */
-  KX_MACRO_addTypesToDict(d, KX_TEXFACE_MATERIAL, KX_TEXFACE_MATERIAL);
-  KX_MACRO_addTypesToDict(d, KX_BLENDER_MULTITEX_MATERIAL, KX_BLENDER_MULTITEX_MATERIAL);
-  KX_MACRO_addTypesToDict(d, KX_BLENDER_GLSL_MATERIAL, KX_BLENDER_GLSL_MATERIAL);
+	/* needed for get/setMaterialType */
+	KX_MACRO_addTypesToDict(d, KX_TEXFACE_MATERIAL, KX_TEXFACE_MATERIAL);
+	KX_MACRO_addTypesToDict(d, KX_BLENDER_MULTITEX_MATERIAL, KX_BLENDER_MULTITEX_MATERIAL);
+	KX_MACRO_addTypesToDict(d, KX_BLENDER_GLSL_MATERIAL, KX_BLENDER_GLSL_MATERIAL);
 
-  // XXXX Add constants here
+	// XXXX Add constants here
 
-  // Check for errors
-  if (PyErr_Occurred())
-    {
-      Py_FatalError("can't initialize module Rasterizer");
-    }
+	// Check for errors
+	if (PyErr_Occurred())
+	{
+		Py_FatalError("can't initialize module Rasterizer");
+	}
 
-  return d;
+	return d;
 }
 
 
@@ -2218,9 +2250,9 @@ PyObject* initGameKeys()
 
 	// Check for errors
 	if (PyErr_Occurred())
-    {
+	{
 		Py_FatalError("can't initialize module GameKeys");
-    }
+	}
 
 	return d;
 }
diff --git a/source/gameengine/Ketsji/KX_RaySensor.cpp b/source/gameengine/Ketsji/KX_RaySensor.cpp
index a683c9857aa..aecf2ab3598 100644
--- a/source/gameengine/Ketsji/KX_RaySensor.cpp
+++ b/source/gameengine/Ketsji/KX_RaySensor.cpp
@@ -83,7 +83,7 @@ void KX_RaySensor::Init()
 
 KX_RaySensor::~KX_RaySensor() 
 {
-    /* Nothing to be done here. */
+	/* Nothing to be done here. */
 }
 
 
@@ -279,7 +279,7 @@ bool KX_RaySensor::Evaluate()
 
 	/* now pass this result to some controller */
 
-    if (m_rayHit)
+	if (m_rayHit)
 	{
 		if (!m_bTriggered)
 		{
@@ -288,14 +288,14 @@ bool KX_RaySensor::Evaluate()
 			m_bTriggered = true;
 		}
 		else
-		  {
+		{
 			// notify logicsystem that ray is STILL hitting ...
 			result = false;
-		    
-		  }
+
+		}
 	}
-    else
-      {
+	else
+	{
 		if (m_bTriggered)
 		{
 			m_bTriggered = false;
@@ -306,9 +306,9 @@ bool KX_RaySensor::Evaluate()
 		{
 			result = false;
 		}
-	
-      }
-    if (reset)
+
+	}
+	if (reset)
 		// force an event
 		result = true;
 
diff --git a/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp b/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
index 076669e325a..c5f3fefd4d3 100644
--- a/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
@@ -44,11 +44,11 @@
 #include "SCA_IScene.h"
 
 KX_SCA_EndObjectActuator::KX_SCA_EndObjectActuator(SCA_IObject *gameobj,
-												   SCA_IScene* scene):
-	SCA_IActuator(gameobj, KX_ACT_END_OBJECT),
-	m_scene(scene)
+                                                   SCA_IScene* scene):
+    SCA_IActuator(gameobj, KX_ACT_END_OBJECT),
+    m_scene(scene)
 {
-    // intentionally empty 
+	// intentionally empty
 } /* End of constructor */
 
 
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 5e0e46026df..00638478349 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -169,6 +169,7 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 	m_lightlist= new CListValue();
 	m_inactivelist = new CListValue();
 	m_euthanasyobjects = new CListValue();
+	m_animatedlist = new CListValue();
 
 	m_logicmgr = new SCA_LogicManager();
 	
@@ -270,6 +271,9 @@ KX_Scene::~KX_Scene()
 	if (m_euthanasyobjects)
 		m_euthanasyobjects->Release();
 
+	if (m_animatedlist)
+		m_animatedlist->Release();
+
 	if (m_logicmgr)
 		delete m_logicmgr;
 
@@ -1519,7 +1523,22 @@ void KX_Scene::LogicBeginFrame(double curtime)
 	m_logicmgr->BeginFrame(curtime, 1.0/KX_KetsjiEngine::GetTicRate());
 }
 
+void KX_Scene::AddAnimatedObject(CValue* gameobj)
+{
+	m_animatedlist->Add(gameobj);
+}
 
+void KX_Scene::RemoveAnimatedObject(CValue* gameobj)
+{
+	m_animatedlist->RemoveValue(gameobj);
+}
+
+void KX_Scene::UpdateAnimations(double curtime)
+{
+	// Update any animations
+	for (int i=0; i<m_animatedlist->GetCount(); ++i)
+		((KX_GameObject*)GetObjectList()->GetValue(i))->UpdateActionManager(curtime);
+}
 
 void KX_Scene::LogicUpdateFrame(double curtime, bool frame)
 {
@@ -1689,6 +1708,11 @@ double KX_Scene::getSuspendedDelta()
 	return m_suspendeddelta;
 }
 
+short KX_Scene::GetAnimationFPS()
+{
+	return m_blenderScene->r.frs_sec;
+}
+
 #ifdef USE_BULLET
 #include "KX_BulletPhysicsController.h"
 #endif
diff --git a/source/gameengine/Ketsji/KX_Scene.h b/source/gameengine/Ketsji/KX_Scene.h
index 26dec2d612b..5954d5465ba 100644
--- a/source/gameengine/Ketsji/KX_Scene.h
+++ b/source/gameengine/Ketsji/KX_Scene.h
@@ -131,6 +131,7 @@ protected:
 	CListValue*			m_parentlist; // all 'root' parents
 	CListValue*			m_lightlist;
 	CListValue*			m_inactivelist;	// all objects that are not in the active layer
+	CListValue*			m_animatedlist; // all animated objects
 	
 	SG_QList			m_sghead;		// list of nodes that needs scenegraph update
 										// the Dlist is not object that must be updated
@@ -338,12 +339,17 @@ public:
 	int NewRemoveObject(CValue* gameobj);
 	void ReplaceMesh(CValue* gameobj,
 					 void* meshob, bool use_gfx, bool use_phys);
+
+	void AddAnimatedObject(CValue* gameobj);
+	void RemoveAnimatedObject(CValue* gameobj);
+
 	/**
 	 * @section Logic stuff
 	 * Initiate an update of the logic system.
 	 */
 	void LogicBeginFrame(double curtime);
 	void LogicUpdateFrame(double curtime, bool frame);
+	void UpdateAnimations(double curtime);
 
 		void						
 	LogicEndFrame(
@@ -569,6 +575,8 @@ public:
 	void SetPhysicsEnvironment(class PHY_IPhysicsEnvironment*	physEnv);
 
 	void	SetGravity(const MT_Vector3& gravity);
+
+	short GetAnimationFPS();
 	
 	/**
 	 * Sets the node tree for this scene.
diff --git a/source/gameengine/Ketsji/KX_SoundActuator.cpp b/source/gameengine/Ketsji/KX_SoundActuator.cpp
index 45ba827a1b8..6c7b515c095 100644
--- a/source/gameengine/Ketsji/KX_SoundActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SoundActuator.cpp
@@ -36,16 +36,25 @@
 
 
 #include "KX_SoundActuator.h"
-#include "AUD_C-API.h"
+
+#ifdef WITH_AUDASPACE
+#  include "AUD_C-API.h"
+#  include "AUD_PingPongFactory.h"
+#  include "AUD_IDevice.h"
+#  include "AUD_I3DHandle.h"
+#endif
+
 #include "KX_GameObject.h"
 #include "KX_PyMath.h" // needed for PyObjectFrom()
+#include "KX_PythonInit.h"
+#include "KX_Camera.h"
 #include <iostream>
 
 /* ------------------------------------------------------------------------- */
 /* Native functions                                                          */
 /* ------------------------------------------------------------------------- */
 KX_SoundActuator::KX_SoundActuator(SCA_IObject* gameobj,
-								   AUD_Sound* sound,
+								   AUD_Reference<AUD_IFactory> sound,
 								   float volume,
 								   float pitch,
 								   bool is3d,
@@ -58,7 +67,6 @@ KX_SoundActuator::KX_SoundActuator(SCA_IObject* gameobj,
 	m_pitch = pitch;
 	m_is3d = is3d;
 	m_3d = settings;
-	m_handle = NULL;
 	m_type = type;
 	m_isplaying = false;
 }
@@ -67,22 +75,20 @@ KX_SoundActuator::KX_SoundActuator(SCA_IObject* gameobj,
 
 KX_SoundActuator::~KX_SoundActuator()
 {
-	if(m_handle)
-		AUD_stop(m_handle);
+	if(!m_handle.isNull())
+		m_handle->stop();
 }
 
 void KX_SoundActuator::play()
 {
-	if(m_handle)
-		AUD_stop(m_handle);
+	if(!m_handle.isNull())
+		m_handle->stop();
 
-	if(!m_sound)
+	if(m_sound.isNull())
 		return;
 
 	// this is the sound that will be played and not deleted afterwards
-	AUD_Sound* sound = m_sound;
-	// this sound is for temporary stacked sounds, will be deleted if not NULL
-	AUD_Sound* sound2 = NULL;
+	AUD_Reference<AUD_IFactory> sound = m_sound;
 
 	bool loop = false;
 
@@ -90,7 +96,7 @@ void KX_SoundActuator::play()
 	{
 	case KX_SOUNDACT_LOOPBIDIRECTIONAL:
 	case KX_SOUNDACT_LOOPBIDIRECTIONAL_STOP:
-		sound = sound2 = AUD_pingpongSound(sound);
+		sound =  new AUD_PingPongFactory(sound);
 		// fall through
 	case KX_SOUNDACT_LOOPEND:
 	case KX_SOUNDACT_LOOPSTOP:
@@ -102,32 +108,28 @@ void KX_SoundActuator::play()
 		break;
 	}
 
-	if(m_is3d)
+	m_handle = AUD_getDevice()->play(sound, 0);
+
+	AUD_Reference<AUD_I3DHandle> handle3d = AUD_Reference<AUD_I3DHandle>(m_handle);
+
+	if(m_is3d && !handle3d.isNull())
 	{
-		// sound shall be played 3D
-		m_handle = AUD_play(sound, 0);
-
-		AUD_setRelative(m_handle, false);
-		AUD_setVolumeMaximum(m_handle, m_3d.max_gain);
-		AUD_setVolumeMinimum(m_handle, m_3d.min_gain);
-		AUD_setDistanceReference(m_handle, m_3d.reference_distance);
-		AUD_setDistanceMaximum(m_handle, m_3d.max_distance);
-		AUD_setAttenuation(m_handle, m_3d.rolloff_factor);
-		AUD_setConeAngleInner(m_handle, m_3d.cone_inner_angle);
-		AUD_setConeAngleOuter(m_handle, m_3d.cone_outer_angle);
-		AUD_setConeVolumeOuter(m_handle, m_3d.cone_outer_gain);
+		handle3d->setRelative(true);
+		handle3d->setVolumeMaximum(m_3d.max_gain);
+		handle3d->setVolumeMinimum(m_3d.min_gain);
+		handle3d->setDistanceReference(m_3d.reference_distance);
+		handle3d->setDistanceMaximum(m_3d.max_distance);
+		handle3d->setAttenuation(m_3d.rolloff_factor);
+		handle3d->setConeAngleInner(m_3d.cone_inner_angle);
+		handle3d->setConeAngleOuter(m_3d.cone_outer_angle);
+		handle3d->setConeVolumeOuter(m_3d.cone_outer_gain);
 	}
-	else
-		m_handle = AUD_play(sound, 0);
 
 	if(loop)
-		AUD_setLoop(m_handle, -1);
-	AUD_setSoundPitch(m_handle, m_pitch);
-	AUD_setSoundVolume(m_handle, m_volume);
+		m_handle->setLoopCount(-1);
+	m_handle->setPitch(m_pitch);
+	m_handle->setVolume(m_volume);
 	m_isplaying = true;
-
-	if(sound2)
-		AUD_unload(sound2);
 }
 
 CValue* KX_SoundActuator::GetReplica()
@@ -140,7 +142,7 @@ CValue* KX_SoundActuator::GetReplica()
 void KX_SoundActuator::ProcessReplica()
 {
 	SCA_IActuator::ProcessReplica();
-	m_handle = 0;
+	m_handle = AUD_Reference<AUD_IHandle>();
 }
 
 bool KX_SoundActuator::Update(double curtime, bool frame)
@@ -155,11 +157,11 @@ bool KX_SoundActuator::Update(double curtime, bool frame)
 	
 	RemoveAllEvents();
 
-	if(!m_sound)
+	if(m_sound.isNull())
 		return false;
 
 	// actual audio device playing state
-	bool isplaying = AUD_getStatus(m_handle) == AUD_STATUS_PLAYING;
+	bool isplaying = m_handle.isNull() ? false : (m_handle->getStatus() == AUD_STATUS_PLAYING);
 
 	if (bNegativeEvent)
 	{
@@ -173,7 +175,9 @@ bool KX_SoundActuator::Update(double curtime, bool frame)
 			case KX_SOUNDACT_LOOPBIDIRECTIONAL_STOP:
 				{
 					// stop immediately
-					AUD_stop(m_handle);
+					if(!m_handle.isNull())
+						m_handle->stop();
+					m_handle = AUD_Reference<AUD_IHandle>();
 					break;
 				}
 			case KX_SOUNDACT_PLAYEND:
@@ -185,7 +189,8 @@ bool KX_SoundActuator::Update(double curtime, bool frame)
 			case KX_SOUNDACT_LOOPBIDIRECTIONAL:
 				{
 					// stop the looping so that the sound stops when it finished
-					AUD_setLoop(m_handle, 0);
+					if(!m_handle.isNull())
+						m_handle->setLoopCount(0);
 					break;
 				}
 			default:
@@ -211,21 +216,35 @@ bool KX_SoundActuator::Update(double curtime, bool frame)
 			play();
 	}
 	// verify that the sound is still playing
-	isplaying = AUD_getStatus(m_handle) == AUD_STATUS_PLAYING ? true : false;
+	isplaying = m_handle.isNull() ? false : (m_handle->getStatus() == AUD_STATUS_PLAYING);
 
 	if (isplaying)
 	{
-		if(m_is3d)
+		AUD_Reference<AUD_I3DHandle> handle3d = AUD_Reference<AUD_I3DHandle>(m_handle);
+
+		if(m_is3d && !handle3d.isNull())
 		{
-			KX_GameObject* obj = (KX_GameObject*)this->GetParent();
-			float f[4];
-
-			obj->NodeGetWorldPosition().getValue(f);
-			AUD_setSourceLocation(m_handle, f);
-			obj->GetLinearVelocity().getValue(f);
-			AUD_setSourceVelocity(m_handle, f);
-			obj->NodeGetWorldOrientation().getRotation().getValue(f);
-			AUD_setSourceOrientation(m_handle, f);
+			KX_Camera* cam = KX_GetActiveScene()->GetActiveCamera();
+			if (cam)
+			{
+				KX_GameObject* obj = (KX_GameObject*)this->GetParent();
+				MT_Point3 p;
+				MT_Matrix3x3 Mo;
+				AUD_Vector3 v;
+				float q[4];
+
+				Mo = cam->NodeGetWorldOrientation().inverse();
+				p = (obj->NodeGetWorldPosition() - cam->NodeGetWorldPosition());
+				p = Mo * p;
+				p.getValue(v.get());
+				handle3d->setSourceLocation(v);
+				p = (obj->GetLinearVelocity() - cam->GetLinearVelocity());
+				p = Mo * p;
+				p.getValue(v.get());
+				handle3d->setSourceVelocity(v);
+				(Mo * obj->NodeGetWorldOrientation()).getRotation().getValue(q);
+				handle3d->setSourceOrientation(AUD_Quaternion(q[3], q[0], q[1], q[2]));
+			}
 		}
 		result = true;
 	}
@@ -237,7 +256,6 @@ bool KX_SoundActuator::Update(double curtime, bool frame)
 	return result;
 }
 
-
 #ifdef WITH_PYTHON
 
 /* ------------------------------------------------------------------------- */
@@ -286,6 +304,7 @@ PyAttributeDef KX_SoundActuator::Attributes[] = {
 	KX_PYATTRIBUTE_RW_FUNCTION("cone_angle_inner", KX_SoundActuator, pyattr_get_3d_property, pyattr_set_3d_property),
 	KX_PYATTRIBUTE_RW_FUNCTION("cone_angle_outer", KX_SoundActuator, pyattr_get_3d_property, pyattr_set_3d_property),
 	KX_PYATTRIBUTE_RW_FUNCTION("cone_volume_outer", KX_SoundActuator, pyattr_get_3d_property, pyattr_set_3d_property),
+	KX_PYATTRIBUTE_RW_FUNCTION("sound", KX_SoundActuator, pyattr_get_sound, pyattr_set_sound),
 
 	KX_PYATTRIBUTE_RW_FUNCTION("time", KX_SoundActuator, pyattr_get_audposition, pyattr_set_audposition),
 	KX_PYATTRIBUTE_RW_FUNCTION("volume", KX_SoundActuator, pyattr_get_gain, pyattr_set_gain),
@@ -299,15 +318,18 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_SoundActuator, startSound,
 "startSound()\n"
 "\tStarts the sound.\n")
 {
-	switch(AUD_getStatus(m_handle))
+	if(!m_handle.isNull())
 	{
-	case AUD_STATUS_PLAYING:
-		break;
-	case AUD_STATUS_PAUSED:
-		AUD_resume(m_handle);
-		break;
-	default:
-		play();
+		switch(m_handle->getStatus())
+		{
+		case AUD_STATUS_PLAYING:
+			break;
+		case AUD_STATUS_PAUSED:
+			m_handle->resume();
+			break;
+		default:
+			play();
+		}
 	}
 	Py_RETURN_NONE;
 }
@@ -316,7 +338,8 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_SoundActuator, pauseSound,
 "pauseSound()\n"
 "\tPauses the sound.\n")
 {
-	AUD_pause(m_handle);
+	if(!m_handle.isNull())
+		m_handle->pause();
 	Py_RETURN_NONE;
 }
 
@@ -324,7 +347,9 @@ KX_PYMETHODDEF_DOC_NOARGS(KX_SoundActuator, stopSound,
 "stopSound()\n"
 "\tStops the sound.\n")
 {
-	AUD_stop(m_handle);
+	if(!m_handle.isNull())
+		m_handle->stop();
+	m_handle = AUD_Reference<AUD_IHandle>();
 	Py_RETURN_NONE;
 }
 
@@ -372,8 +397,8 @@ PyObject* KX_SoundActuator::pyattr_get_audposition(void *self, const struct KX_P
 	KX_SoundActuator * actuator = static_cast<KX_SoundActuator *> (self);
 	float position = 0.0;
 
-	if(actuator->m_handle)
-		position = AUD_getPosition(actuator->m_handle);
+	if(!actuator->m_handle.isNull())
+		position = actuator->m_handle->getPosition();
 
 	PyObject* result = PyFloat_FromDouble(position);
 
@@ -400,6 +425,15 @@ PyObject* KX_SoundActuator::pyattr_get_pitch(void *self, const struct KX_PYATTRI
 	return result;
 }
 
+PyObject* KX_SoundActuator::pyattr_get_sound(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	KX_SoundActuator * actuator = static_cast<KX_SoundActuator *> (self);
+	if(!actuator->m_sound.isNull())
+		return AUD_getPythonFactory(&actuator->m_sound);
+	else
+		Py_RETURN_NONE;
+}
+
 int KX_SoundActuator::pyattr_set_3d_property(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
 {
 	KX_SoundActuator * actuator = static_cast<KX_SoundActuator *> (self);
@@ -409,49 +443,50 @@ int KX_SoundActuator::pyattr_set_3d_property(void *self, const struct KX_PYATTRI
 	if (!PyArg_Parse(value, "f", &prop_value))
 		return PY_SET_ATTR_FAIL;
 
+	AUD_Reference<AUD_I3DHandle> handle3d = AUD_Reference<AUD_I3DHandle>(actuator->m_handle);
 	// if sound is working and 3D, set the new setting
 	if(!actuator->m_is3d)
 		return PY_SET_ATTR_FAIL;
 
 	if(!strcmp(prop, "volume_maximum")) {
 		actuator->m_3d.max_gain = prop_value;
-		if(actuator->m_handle)
-			AUD_setVolumeMaximum(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setVolumeMaximum(prop_value);
 
 	} else if (!strcmp(prop, "volume_minimum")) {
 		actuator->m_3d.min_gain = prop_value;
-		if(actuator->m_handle)
-			AUD_setVolumeMinimum(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setVolumeMinimum(prop_value);
 
 	} else if (!strcmp(prop, "distance_reference")) {
 		actuator->m_3d.reference_distance = prop_value;
-		if(actuator->m_handle)
-			AUD_setDistanceReference(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setDistanceReference(prop_value);
 
 	} else if (!strcmp(prop, "distance_maximum")) {
 		actuator->m_3d.max_distance = prop_value;
-		if(actuator->m_handle)
-			AUD_setDistanceMaximum(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setDistanceMaximum(prop_value);
 
 	} else if (!strcmp(prop, "attenuation")) {
 		actuator->m_3d.rolloff_factor = prop_value;
-		if(actuator->m_handle)
-			AUD_setAttenuation(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setAttenuation(prop_value);
 
 	} else if (!!strcmp(prop, "cone_angle_inner")) {
 		actuator->m_3d.cone_inner_angle = prop_value;
-		if(actuator->m_handle)
-			AUD_setConeAngleInner(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setConeAngleInner(prop_value);
 
 	} else if (!strcmp(prop, "cone_angle_outer")) {
 		actuator->m_3d.cone_outer_angle = prop_value;
-		if(actuator->m_handle)
-			AUD_setConeAngleOuter(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setConeAngleOuter(prop_value);
 
 	} else if (!strcmp(prop, "cone_volume_outer")) {
 		actuator->m_3d.cone_outer_gain = prop_value;
-		if(actuator->m_handle)
-			AUD_setConeVolumeOuter(actuator->m_handle, prop_value);
+		if(!handle3d.isNull())
+			handle3d->setConeVolumeOuter(prop_value);
 
 	} else {
 		return PY_SET_ATTR_FAIL;
@@ -468,8 +503,8 @@ int KX_SoundActuator::pyattr_set_audposition(void *self, const struct KX_PYATTRI
 	if (!PyArg_Parse(value, "f", &position))
 		return PY_SET_ATTR_FAIL;
 
-	if(actuator->m_handle)
-		AUD_seek(actuator->m_handle, position);
+	if(!actuator->m_handle.isNull())
+		actuator->m_handle->seek(position);
 	return PY_SET_ATTR_SUCCESS;
 }
 
@@ -481,8 +516,8 @@ int KX_SoundActuator::pyattr_set_gain(void *self, const struct KX_PYATTRIBUTE_DE
 		return PY_SET_ATTR_FAIL;
 
 	actuator->m_volume = gain;
-	if(actuator->m_handle)
-		AUD_setSoundVolume(actuator->m_handle, gain);
+	if(!actuator->m_handle.isNull())
+		actuator->m_handle->setVolume(gain);
 
 	return PY_SET_ATTR_SUCCESS;
 }
@@ -495,10 +530,28 @@ int KX_SoundActuator::pyattr_set_pitch(void *self, const struct KX_PYATTRIBUTE_D
 		return PY_SET_ATTR_FAIL;
 
 	actuator->m_pitch = pitch;
-	if(actuator->m_handle)
-		AUD_setSoundPitch(actuator->m_handle, pitch);
+	if(!actuator->m_handle.isNull())
+		actuator->m_handle->setPitch(pitch);
 
 	return PY_SET_ATTR_SUCCESS;
 }
 
+int KX_SoundActuator::pyattr_set_sound(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	PyObject* sound = NULL;
+	KX_SoundActuator * actuator = static_cast<KX_SoundActuator *> (self);
+	if (!PyArg_Parse(value, "O", &sound))
+		return PY_SET_ATTR_FAIL;
+
+	AUD_Reference<AUD_IFactory>* snd = reinterpret_cast<AUD_Reference<AUD_IFactory>*>(AUD_getPythonSound(sound));
+	if(snd)
+	{
+		actuator->m_sound = *snd;
+		delete snd;
+		return PY_SET_ATTR_SUCCESS;
+	}
+
+	return PY_SET_ATTR_FAIL;
+}
+
 #endif // WITH_PYTHON
diff --git a/source/gameengine/Ketsji/KX_SoundActuator.h b/source/gameengine/Ketsji/KX_SoundActuator.h
index e7257245a80..b1161e0cad2 100644
--- a/source/gameengine/Ketsji/KX_SoundActuator.h
+++ b/source/gameengine/Ketsji/KX_SoundActuator.h
@@ -36,7 +36,13 @@
 
 #include "SCA_IActuator.h"
 
-#include "AUD_C-API.h"
+#ifdef WITH_AUDASPACE
+#  include "AUD_C-API.h"
+#  include "AUD_Reference.h"
+#  include "AUD_IFactory.h"
+#  include "AUD_IHandle.h"
+#endif
+
 #include "BKE_sound.h"
 
 typedef struct KX_3DSoundSettings
@@ -53,14 +59,14 @@ typedef struct KX_3DSoundSettings
 
 class KX_SoundActuator : public SCA_IActuator
 {
-        Py_Header;
-        bool					m_isplaying;
-	AUD_Sound*				m_sound;
+	Py_Header;
+	bool					m_isplaying;
+	AUD_Reference<AUD_IFactory>				m_sound;
 	float					m_volume;
 	float					m_pitch;
 	bool					m_is3d;
 	KX_3DSoundSettings		m_3d;
-		AUD_Channel*				m_handle;
+	AUD_Reference<AUD_IHandle>				m_handle;
 
 	void play();
 
@@ -81,7 +87,7 @@ public:
 	KX_SOUNDACT_TYPE		m_type;
 
 	KX_SoundActuator(SCA_IObject* gameobj,
-					 AUD_Sound* sound,
+					 AUD_Reference<AUD_IFactory> sound,
 					 float volume,
 					 float pitch,
 					 bool is3d,
@@ -110,12 +116,14 @@ public:
 	static int pyattr_set_gain(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 	static int pyattr_set_pitch(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 	static int pyattr_set_type(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	static int pyattr_set_sound(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
 
 	static PyObject* pyattr_get_3d_property(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject* pyattr_get_audposition(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject* pyattr_get_gain(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject* pyattr_get_pitch(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 	static PyObject* pyattr_get_type(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject* pyattr_get_sound(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 
 #endif // WITH_PYTHON
 
diff --git a/source/gameengine/Ketsji/KX_TrackToActuator.cpp b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
index edcba969811..f13f152c5d5 100644
--- a/source/gameengine/Ketsji/KX_TrackToActuator.cpp
+++ b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
@@ -54,16 +54,16 @@
 
 
 KX_TrackToActuator::KX_TrackToActuator(SCA_IObject *gameobj, 
-								       SCA_IObject *ob,
-									   int time,
-									   bool allow3D,
-									   int trackflag,
-									   int upflag)
-									   : SCA_IActuator(gameobj, KX_ACT_TRACKTO)
+                                       SCA_IObject *ob,
+                                       int time,
+                                       bool allow3D,
+                                       int trackflag,
+                                       int upflag)
+    : SCA_IActuator(gameobj, KX_ACT_TRACKTO)
 {
-    m_time = time;
-    m_allow3D = allow3D;
-    m_object = ob;
+	m_time = time;
+	m_allow3D = allow3D;
+	m_object = ob;
 	m_trackflag = trackflag;
 	m_upflag = upflag;
 	m_parentobj = 0;
diff --git a/source/gameengine/Ketsji/KX_TrackToActuator.h b/source/gameengine/Ketsji/KX_TrackToActuator.h
index c5e96bd7454..bbf0134a859 100644
--- a/source/gameengine/Ketsji/KX_TrackToActuator.h
+++ b/source/gameengine/Ketsji/KX_TrackToActuator.h
@@ -57,7 +57,7 @@ class KX_TrackToActuator : public SCA_IActuator
 
   public:
 	KX_TrackToActuator(SCA_IObject* gameobj, SCA_IObject *ob, int time,
-				       bool threedee,int trackflag,int upflag);
+	                   bool threedee,int trackflag,int upflag);
 	virtual ~KX_TrackToActuator();
 	virtual CValue* GetReplica() {
 		KX_TrackToActuator* replica = new KX_TrackToActuator(*this);
diff --git a/source/gameengine/Ketsji/SConscript b/source/gameengine/Ketsji/SConscript
index 11dd0e5a4bf..7c9785c24e7 100644
--- a/source/gameengine/Ketsji/SConscript
+++ b/source/gameengine/Ketsji/SConscript
@@ -6,15 +6,16 @@ Import ('env')
 sources = env.Glob('*.cpp')
 defs = [ 'GLEW_STATIC' ]
 
-incs = '. #source/blender/python/generic' # Only for Mathutils! and bpy_internal_import.h, be very careful
+incs = '. #source/blender/python/generic' # Only for bpy_internal_import.h, be very careful
+incs += ' #source/blender/python/mathutils' # Only for mathutils, be very careful
 
 incs += ' #intern/string #intern/guardedalloc #intern/container'
 incs += ' #source/gameengine/Rasterizer/RAS_OpenGLRasterizer'
-incs += ' #intern/audaspace/intern #source/gameengine/Converter'
+incs += ' #intern/audaspace/intern #intern/audaspace/FX #source/gameengine/Converter'
 incs += ' #source/gameengine/BlenderRoutines #source/blender/imbuf #intern/moto/include'
 incs += ' #source/gameengine/Ketsji #source/gameengine/Ketsji/KXNetwork #source/blender/blenlib #source/blender/blenfont'
 incs += ' #source/blender/blenkernel #source/blender #source/blender/editors/include'
-incs += ' #source/blender/makesdna #source/blender/python #source/gameengine/Rasterizer'
+incs += ' #source/blender/makesdna #source/blender/makesrna #source/blender/python #source/gameengine/Rasterizer'
 incs += ' #source/gameengine/GameLogic #source/gameengine/Expressions #source/gameengine/Network'
 incs += ' #source/gameengine/SceneGraph #source/gameengine/Physics/common'
 incs += ' #source/gameengine/Physics/Dummy'
@@ -36,7 +37,7 @@ if env['WITH_BF_PYTHON']:
 
 if env['WITH_BF_FFMPEG']:
     defs.append('WITH_FFMPEG')
-    
+
 if env['OURPLATFORM'] in ('win32-vc', 'win64-vc', 'win32-mingw'):
     if env['BF_DEBUG']:
         defs.append('_DEBUG') # for Python
diff --git a/source/gameengine/Network/CMakeLists.txt b/source/gameengine/Network/CMakeLists.txt
index e1f3bfaac77..4d6d035c63d 100644
--- a/source/gameengine/Network/CMakeLists.txt
+++ b/source/gameengine/Network/CMakeLists.txt
@@ -26,9 +26,9 @@
 
 set(INC
 	.
-	../../../intern/string
 	../../../intern/container
 	../../../intern/moto/include
+	../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Network/LoopBackNetwork/CMakeLists.txt b/source/gameengine/Network/LoopBackNetwork/CMakeLists.txt
index 9c3936987f2..c816a30f1a8 100644
--- a/source/gameengine/Network/LoopBackNetwork/CMakeLists.txt
+++ b/source/gameengine/Network/LoopBackNetwork/CMakeLists.txt
@@ -26,9 +26,9 @@
 
 set(INC
 	.
-	../../../../intern/string
+	..
 	../../../../intern/container
-	../../../../source/gameengine/Network
+	../../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Network/LoopBackNetwork/NG_LoopBackNetworkDeviceInterface.h b/source/gameengine/Network/LoopBackNetwork/NG_LoopBackNetworkDeviceInterface.h
index 67d0e741507..cb7807a86a6 100644
--- a/source/gameengine/Network/LoopBackNetwork/NG_LoopBackNetworkDeviceInterface.h
+++ b/source/gameengine/Network/LoopBackNetwork/NG_LoopBackNetworkDeviceInterface.h
@@ -52,8 +52,8 @@ public:
 	virtual void NextFrame();
 
 	bool Connect(char *address, unsigned int port, char *password,
-		     unsigned int localport, unsigned int timeout) {
-	    return true;}
+	             unsigned int localport, unsigned int timeout) {
+		return true;}
 	bool Disconnect(void) {return true;}
 
 	virtual void SendNetworkMessage(class NG_NetworkMessage* msg);
diff --git a/source/gameengine/Network/NG_NetworkDeviceInterface.h b/source/gameengine/Network/NG_NetworkDeviceInterface.h
index 6df228680ec..857b4660327 100644
--- a/source/gameengine/Network/NG_NetworkDeviceInterface.h
+++ b/source/gameengine/Network/NG_NetworkDeviceInterface.h
@@ -64,7 +64,7 @@ public:
 	bool IsOnline(void) { return m_online; }
 
 	virtual bool Connect(char *address, unsigned int port, char *password,
-		     unsigned int localport, unsigned int timeout)=0;
+	                     unsigned int localport, unsigned int timeout)=0;
 	virtual bool Disconnect(void)=0;
 
 	virtual void SendNetworkMessage(NG_NetworkMessage* msg)=0;
diff --git a/source/gameengine/Physics/Bullet/CMakeLists.txt b/source/gameengine/Physics/Bullet/CMakeLists.txt
index aadd11cc036..971c8f979f3 100644
--- a/source/gameengine/Physics/Bullet/CMakeLists.txt
+++ b/source/gameengine/Physics/Bullet/CMakeLists.txt
@@ -30,19 +30,19 @@ remove_strict_flags()
 set(INC
 	.
 	../common
-	../../../../extern/bullet2/src
-	../../../../intern/moto/include
-	../../../../intern/guardedalloc
-	../../../../intern/container
-	../../../../intern/string
-	../../Rasterizer
-	../../Ketsji
 	../../Expressions
 	../../GameLogic
+	../../Ketsji
+	../../Rasterizer
 	../../SceneGraph
-	../../../../source/blender/makesdna
-	../../../../source/blender/blenlib
-	../../../../source/blender/blenkernel
+	../../../blender/blenkernel
+	../../../blender/blenlib
+	../../../blender/makesdna
+	../../../../extern/bullet2/src
+	../../../../intern/container
+	../../../../intern/guardedalloc
+	../../../../intern/moto/include
+	../../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
index 0c5cbb22fbc..2bc11ef5f5b 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
@@ -2142,6 +2142,7 @@ btCollisionShape* CcdShapeConstructionInfo::CreateBulletShape(btScalar margin, b
 			}
 			collisionShape = compoundShape;
 		}
+		break;
 	}
 	return collisionShape;
 }
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.h b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
index 97dc65c5850..82acd64161f 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
@@ -216,28 +216,53 @@ struct CcdConstructionInfo
 	///more advanced collision filtering should be done in btCollisionDispatcher::NeedsCollision
 	enum CollisionFilterGroups
 	{
-	        DefaultFilter = 1,
-	        StaticFilter = 2,
-	        KinematicFilter = 4,
-	        DebrisFilter = 8,
-			SensorFilter = 16,
-	        AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorFilter,
+		DefaultFilter = 1,
+		StaticFilter = 2,
+		KinematicFilter = 4,
+		DebrisFilter = 8,
+		SensorFilter = 16,
+		AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorFilter,
 	};
 
 
 	CcdConstructionInfo()
-		: m_localInertiaTensor(1.f, 1.f, 1.f),
+	    :m_localInertiaTensor(1.f, 1.f, 1.f),
 		m_gravity(0,0,0),
 		m_scaling(1.f,1.f,1.f),
 		m_mass(0.f),
-		m_clamp_vel_min(-1.f), 
-		m_clamp_vel_max(-1.f), 
+		m_clamp_vel_min(-1.f),
+		m_clamp_vel_max(-1.f),
 		m_restitution(0.1f),
 		m_friction(0.5f),
 		m_linearDamping(0.1f),
 		m_angularDamping(0.1f),
 		m_margin(0.06f),
 		m_gamesoftFlag(0),
+		m_soft_linStiff(1.f),
+		m_soft_angStiff(1.f),
+		m_soft_volume(1.f),
+		m_soft_viterations(0),
+		m_soft_piterations(1),
+		m_soft_diterations(0),
+		m_soft_citerations(4),
+		m_soft_kSRHR_CL(0.1f),
+		m_soft_kSKHR_CL(1.f),
+		m_soft_kSSHR_CL(0.5f),
+		m_soft_kSR_SPLT_CL(0.5f),
+		m_soft_kSK_SPLT_CL(0.5f),
+		m_soft_kSS_SPLT_CL(0.5f),
+		m_soft_kVCF(1.f),
+		m_soft_kDP(0.f),
+		m_soft_kDG(0.f),
+		m_soft_kLF(0.f),
+		m_soft_kPR(0.f),
+		m_soft_kVC(0.f),
+		m_soft_kDF(0.2f),
+		m_soft_kMT(0),
+		m_soft_kCHR(1.0f),
+		m_soft_kKHR(0.1f),
+		m_soft_kSHR(1.0f),
+		m_soft_kAHR(0.7f),
 		m_collisionFlags(0),
 		m_bRigid(false),
 		m_bSoft(false),
@@ -252,38 +277,13 @@ struct CcdConstructionInfo
 		m_inertiaFactor(1.f),
 		m_do_anisotropic(false),
 		m_anisotropicFriction(1.f,1.f,1.f),
-		m_contactProcessingThreshold(1e10f),
-		m_soft_linStiff(1.f),
-		m_soft_angStiff(1.f),
-		m_soft_volume(1.f),
-		m_soft_viterations(0),
-		m_soft_piterations(1),
-		m_soft_diterations(0),
-		m_soft_citerations(4),
 		m_do_fh(false),
 		m_do_rot_fh(false),
 		m_fh_spring(0.f),
 		m_fh_damping(0.f),
 		m_fh_distance(1.f),
 		m_fh_normal(false),
-	m_soft_kVCF(1.f),
-	m_soft_kDG(0.f),
-	m_soft_kLF(0.f),
-	m_soft_kDP(0.f),
-	m_soft_kPR(0.f),
-	m_soft_kVC(0.f),
-	m_soft_kDF(0.2f),
-	m_soft_kMT(0),
-	m_soft_kCHR(1.0f),
-	m_soft_kKHR(0.1f),
-	m_soft_kSHR(1.0f),
-	m_soft_kAHR(0.7f),
-	m_soft_kSRHR_CL(0.1f),
-	m_soft_kSKHR_CL(1.f),
-	m_soft_kSSHR_CL(0.5f),
-	m_soft_kSR_SPLT_CL(0.5f),
-	m_soft_kSK_SPLT_CL(0.5f),
-	m_soft_kSS_SPLT_CL(0.5f)
+		m_contactProcessingThreshold(1e10f)
 	{
 
 	}
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index 3f0c4cb95a1..39b2022a1f4 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -1200,7 +1200,7 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IRayCastFilterCallbac
 						
 					// Bullet returns the normal from "outside".
 					// If the user requests the real normal, compute it now
-                    if (filterCallback.m_faceNormal)
+					if (filterCallback.m_faceNormal)
 					{
 						if (shape->isSoftBody()) 
 						{
@@ -2564,8 +2564,8 @@ int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl
 				btPlaneSpace1( axisInA, axis1, axis2 );
 
 				frameInA.getBasis().setValue( axisInA.x(), axis1.x(), axis2.x(),
-					                          axisInA.y(), axis1.y(), axis2.y(),
-											  axisInA.z(), axis1.z(), axis2.z() );
+				                              axisInA.y(), axis1.y(), axis2.y(),
+				                              axisInA.z(), axis1.z(), axis2.z() );
 
 				frameInA.setOrigin( pivotInA );
 
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
index 51e00b9111f..c34a00513bf 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
@@ -128,7 +128,7 @@ protected:
 		virtual	void		setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep)
 		{
 			//based on DEFAULT_PHYSICS_TIC_RATE of 60 hertz
-			setNumTimeSubSteps(fixedTimeStep/60.f);
+			setNumTimeSubSteps((int)(fixedTimeStep / 60.f));
 		}
 		//returns 0.f if no fixed timestep is used
 
@@ -164,7 +164,7 @@ protected:
 		
 		virtual float	getConstraintParam(int constraintId,int param);
 
-	    virtual void		removeConstraint(int	constraintid);
+		virtual void		removeConstraint(int	constraintid);
 
 		virtual float		getAppliedImpulse(int	constraintid);
 
diff --git a/source/gameengine/Rasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/CMakeLists.txt
index b705d3151b2..23d746f88bc 100644
--- a/source/gameengine/Rasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/CMakeLists.txt
@@ -26,14 +26,14 @@
 
 set(INC
 	.
-	../../../source/blender/makesdna
-	../../../source/gameengine/SceneGraph
-	../../../source/gameengine/Ketsji
-	../../../intern/string
+	../Expressions
+	../Ketsji
+	../SceneGraph
+	../../blender/makesdna
 	../../../intern/container
-	../../../intern/moto/include
 	../../../intern/guardedalloc
-	../Expressions
+	../../../intern/moto/include
+	../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp b/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
index ed18ff0329e..725d00aa5cd 100644
--- a/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
+++ b/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
@@ -306,8 +306,8 @@ void RAS_2DFilterManager::SetupTextures(bool depth, bool luminance)
 	if(depth){
 		glGenTextures(1, (GLuint*)&texname[1]);
 		glBindTexture(GL_TEXTURE_2D, texname[1]);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, texturewidth,textureheight, 
-			0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE,NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, texturewidth,textureheight,
+		             0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE,NULL);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
 		                GL_NONE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -433,6 +433,9 @@ void RAS_2DFilterManager::RenderFilters(RAS_ICanvas* canvas)
 		glCopyTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE16, 0, 0, texturewidth,textureheight, 0);
 	}
 
+	// reverting to texunit 0, without this we get bug [#28462]
+	glActiveTextureARB(GL_TEXTURE0);
+
 	glViewport(0,0, texturewidth, textureheight);
 
 	glDisable(GL_DEPTH_TEST);
diff --git a/source/gameengine/Rasterizer/RAS_CameraData.h b/source/gameengine/Rasterizer/RAS_CameraData.h
index e6254f72511..5657fda4f3c 100644
--- a/source/gameengine/Rasterizer/RAS_CameraData.h
+++ b/source/gameengine/Rasterizer/RAS_CameraData.h
@@ -49,19 +49,19 @@ struct RAS_CameraData
 	float m_focallength;
 
 	RAS_CameraData(float lens = 35.0, float scale = 6.0, float clipstart = 0.1, float clipend = 5000.0, bool perspective = true,
-	float focallength = 3.0, bool viewport = false, int viewportleft = 0, int viewportbottom = 0, 
-	int viewportright = 0, int viewporttop = 0) :
-		m_lens(lens),
-		m_scale(scale),
-		m_clipstart(clipstart),
-		m_clipend(clipend),
-		m_perspective(perspective),
-		m_viewport(viewport),
-		m_viewportleft(viewportleft),
-		m_viewportbottom(viewportbottom),
-		m_viewportright(viewportright),
-		m_viewporttop(viewporttop),
-        m_focallength(focallength)
+	               float focallength = 3.0, bool viewport = false, int viewportleft = 0, int viewportbottom = 0,
+	               int viewportright = 0, int viewporttop = 0) :
+	    m_lens(lens),
+	    m_scale(scale),
+	    m_clipstart(clipstart),
+	    m_clipend(clipend),
+	    m_perspective(perspective),
+	    m_viewport(viewport),
+	    m_viewportleft(viewportleft),
+	    m_viewportbottom(viewportbottom),
+	    m_viewportright(viewportright),
+	    m_viewporttop(viewporttop),
+	    m_focallength(focallength)
 	{
 	}
 };
diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
index 47f1dcb412a..5a1b52489b4 100644
--- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
+++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
@@ -246,6 +246,11 @@ bool RAS_IPolyMaterial::UsesLighting(RAS_IRasterizer *rasty) const
 	return dolights;
 }
 
+bool RAS_IPolyMaterial::CastsShadows() const
+{
+	return (m_flag & RAS_CASTSHADOW) != 0;
+}
+
 bool RAS_IPolyMaterial::UsesObjectColor() const
 {
 	return !(m_flag & RAS_BLENDERGLSL);
diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
index b0e7daf81d7..2a5c6a179b6 100644
--- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
+++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
@@ -62,7 +62,8 @@ enum MaterialProps
 	RAS_AUTOGEN		=128,
 	RAS_NORMAL		=256,
 	RAS_DEFMULTI	=512,
-	RAS_BLENDERGLSL =1024
+	RAS_BLENDERGLSL =1024,
+	RAS_CASTSHADOW	=2048
 };
 
 /**
@@ -169,6 +170,7 @@ public:
 	virtual void		GetMaterialRGBAColor(unsigned char *rgba) const;
 	virtual bool		UsesLighting(RAS_IRasterizer *rasty) const;
 	virtual bool		UsesObjectColor() const;
+	virtual bool		CastsShadows() const;
 
 	virtual void		Replace_IScene(SCA_IScene *val) {}; /* overridden by KX_BlenderMaterial */
 
diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h
index 142eb88c7c7..877a7219a1c 100644
--- a/source/gameengine/Rasterizer/RAS_IRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h
@@ -419,6 +419,9 @@ public:
 
 	virtual void	SetBlendingMode(int blendmode)=0;
 	virtual void	SetFrontFace(bool ccw)=0;
+
+	virtual void	SetAnisotropicFiltering(short level)=0;
+	virtual short	GetAnisotropicFiltering()=0;
 	
 	
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
index 7647f7d3f27..85284096bb9 100644
--- a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
+++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
@@ -586,6 +586,9 @@ bool RAS_MaterialBucket::ActivateMaterial(const MT_Transform& cameratrans, RAS_I
 	RAS_IRenderTools *rendertools)
 {
 	bool uselights;
+	
+	if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_SHADOW && !m_material->CastsShadows())
+		return false;
 
 	if(!rasty->SetMaterial(*m_material))
 		return false;
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Blur2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Blur2DFilter.h
index a277d9835d8..3a3ea57d67b 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Blur2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Blur2DFilter.h
@@ -38,17 +38,17 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
+	vec4 sample[9];
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+	}
 
-    gl_FragColor = (sample[0] + (2.0*sample[1]) + sample[2] + 
-                    (2.0*sample[3]) + sample[4] + (2.0*sample[5]) + 
-                    sample[6] + (2.0*sample[7]) + sample[8]) / 13.0;
+	gl_FragColor = (sample[0] + (2.0*sample[1]) + sample[2] +
+	                (2.0*sample[3]) + sample[4] + (2.0*sample[5]) +
+	                sample[6] + (2.0*sample[7]) + sample[8]) / 13.0;
 }
 );
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Dilation2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Dilation2DFilter.h
index 6aeff254f77..f486be47f9f 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Dilation2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Dilation2DFilter.h
@@ -38,17 +38,17 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
-    vec4 maxValue = vec4(0.0);
+	vec4 sample[9];
+	vec4 maxValue = vec4(0.0);
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-        maxValue = max(sample[i], maxValue);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+		maxValue = max(sample[i], maxValue);
+	}
 
-    gl_FragColor = maxValue;
+	gl_FragColor = maxValue;
 }
 );
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Erosion2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Erosion2DFilter.h
index 1e9dccaec87..a1755dc0eeb 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Erosion2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Erosion2DFilter.h
@@ -33,22 +33,22 @@
 #define __RAS_EROSION2DFILTER
 
 const char * ErosionFragmentShader=STRINGIFY(
-uniform sampler2D bgl_RenderedTexture;
-uniform vec2 bgl_TextureCoordinateOffset[9];
+            uniform sampler2D bgl_RenderedTexture;
+        uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
-    vec4 minValue = vec4(1.0);
+	vec4 sample[9];
+	vec4 minValue = vec4(1.0);
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-        minValue = min(sample[i], minValue);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+		minValue = min(sample[i], minValue);
+	}
 
-    gl_FragColor = minValue;
+	gl_FragColor = minValue;
 }
 );
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Laplacian2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Laplacian2DFilter.h
index c7cfa83a11f..45c94d358ba 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Laplacian2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Laplacian2DFilter.h
@@ -38,18 +38,18 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
+	vec4 sample[9];
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+	}
 
-    gl_FragColor = (sample[4] * 8.0) - 
-                    (sample[0] + sample[1] + sample[2] + 
-                     sample[3] + sample[5] + 
-                     sample[6] + sample[7] + sample[8]);
+	gl_FragColor = (sample[4] * 8.0) -
+	        (sample[0] + sample[1] + sample[2] +
+	         sample[3] + sample[5] +
+	         sample[6] + sample[7] + sample[8]);
 	gl_FragColor = vec4(gl_FragColor.rgb, 1.0);
 }
 );
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Prewitt2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Prewitt2DFilter.h
index ada53cd751d..8d08d9077cb 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Prewitt2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Prewitt2DFilter.h
@@ -38,23 +38,23 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
+	vec4 sample[9];
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+	}
 
-    vec4 horizEdge = sample[2] + sample[5] + sample[8] -
-                     (sample[0] + sample[3] + sample[6]);
+	vec4 horizEdge = sample[2] + sample[5] + sample[8] -
+	        (sample[0] + sample[3] + sample[6]);
 
-    vec4 vertEdge = sample[0] + sample[1] + sample[2] -
-                    (sample[6] + sample[7] + sample[8]);
+	vec4 vertEdge = sample[0] + sample[1] + sample[2] -
+	        (sample[6] + sample[7] + sample[8]);
 
-    gl_FragColor.rgb = sqrt((horizEdge.rgb * horizEdge.rgb) + 
-                            (vertEdge.rgb * vertEdge.rgb));
-    gl_FragColor.a = 1.0;
+	gl_FragColor.rgb = sqrt((horizEdge.rgb * horizEdge.rgb) +
+	                        (vertEdge.rgb * vertEdge.rgb));
+	gl_FragColor.a = 1.0;
 }
 
 );
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sharpen2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sharpen2DFilter.h
index 0d68bc09c70..a9c827fa9e1 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sharpen2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sharpen2DFilter.h
@@ -38,18 +38,18 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
+	vec4 sample[9];
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+	}
 
-    gl_FragColor = (sample[4] * 9.0) - 
-                    (sample[0] + sample[1] + sample[2] + 
-                     sample[3] + sample[5] + 
-                     sample[6] + sample[7] + sample[8]);
+	gl_FragColor = (sample[4] * 9.0) -
+	        (sample[0] + sample[1] + sample[2] +
+	         sample[3] + sample[5] +
+	         sample[6] + sample[7] + sample[8]);
 }
 );
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sobel2DFilter.h b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sobel2DFilter.h
index 0f80f0f22b4..350ce19fafd 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sobel2DFilter.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLFilters/RAS_Sobel2DFilter.h
@@ -38,23 +38,23 @@ uniform vec2 bgl_TextureCoordinateOffset[9];
 
 void main(void)
 {
-    vec4 sample[9];
+	vec4 sample[9];
 
-    for (int i = 0; i < 9; i++)
-    {
-        sample[i] = texture2D(bgl_RenderedTexture, 
-                              gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
-    }
+	for (int i = 0; i < 9; i++)
+	{
+		sample[i] = texture2D(bgl_RenderedTexture,
+		                      gl_TexCoord[0].st + bgl_TextureCoordinateOffset[i]);
+	}
 
-    vec4 horizEdge = sample[2] + (2.0*sample[5]) + sample[8] -
-                     (sample[0] + (2.0*sample[3]) + sample[6]);
+	vec4 horizEdge = sample[2] + (2.0*sample[5]) + sample[8] -
+	        (sample[0] + (2.0*sample[3]) + sample[6]);
 
-    vec4 vertEdge = sample[0] + (2.0*sample[1]) + sample[2] -
-                    (sample[6] + (2.0*sample[7]) + sample[8]);
+	vec4 vertEdge = sample[0] + (2.0*sample[1]) + sample[2] -
+	        (sample[6] + (2.0*sample[7]) + sample[8]);
 
-    gl_FragColor.rgb = sqrt((horizEdge.rgb * horizEdge.rgb) + 
-                            (vertEdge.rgb * vertEdge.rgb));
-    gl_FragColor.a = 1.0;
+	gl_FragColor.rgb = sqrt((horizEdge.rgb * horizEdge.rgb) +
+	                        (vertEdge.rgb * vertEdge.rgb));
+	gl_FragColor.a = 1.0;
 }
 );
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
index a005bb1108d..b0ef6fab251 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
@@ -25,18 +25,18 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	../../../../intern/string
+	..
+	../../BlenderRoutines
+	../../Ketsji
+	../../SceneGraph
+	../../../blender/blenkernel
+	../../../blender/blenlib
+	../../../blender/blenloader
+	../../../blender/gpu
+	../../../blender/makesdna
 	../../../../intern/container
 	../../../../intern/moto/include
-	../../../../source/gameengine/Rasterizer
-	../../../../source/gameengine/Ketsji
-	../../../../source/gameengine/SceneGraph
-	../../../../source/gameengine/BlenderRoutines
-	../../../../source/blender/gpu
-	../../../../source/blender/makesdna
-	../../../../source/blender/blenkernel
-	../../../../source/blender/blenlib
-	../../../../source/blender/blenloader
+	../../../../intern/string
 )
 
 set(INC_SYS
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
index 59710b69fc0..6ad9e591474 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
@@ -103,12 +103,16 @@ RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
 		hinterlace_mask[i] = (i&1)*0xFFFFFFFF;
 	}
 	hinterlace_mask[32] = 0;
+
+	m_prevafvalue = GPU_get_anisotropic();
 }
 
 
 
 RAS_OpenGLRasterizer::~RAS_OpenGLRasterizer()
 {
+	// Restore the previous AF value
+	GPU_set_anisotropic(m_prevafvalue);
 }
 
 bool RAS_OpenGLRasterizer::Init()
@@ -1246,3 +1250,12 @@ void RAS_OpenGLRasterizer::SetFrontFace(bool ccw)
 	m_last_frontface = ccw;
 }
 
+void RAS_OpenGLRasterizer::SetAnisotropicFiltering(short level)
+{
+	GPU_set_anisotropic((float)level);
+}
+
+short RAS_OpenGLRasterizer::GetAnisotropicFiltering()
+{
+	return (short)GPU_get_anisotropic();
+}
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
index a494c577512..c0e02f6df77 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
@@ -99,6 +99,8 @@ class RAS_OpenGLRasterizer : public RAS_IRasterizer
 	bool			m_setfocallength;
 	int				m_noOfScanlines;
 
+	short			m_prevafvalue;
+
 	//motion blur
 	int	m_motionblur;
 	float	m_motionblurvalue;
@@ -313,6 +315,9 @@ public:
 	virtual void	SetBlendingMode(int blendmode);
 	virtual void	SetFrontFace(bool ccw);
 	
+	virtual void	SetAnisotropicFiltering(short level);
+	virtual short	GetAnisotropicFiltering();
+	
 	
 #ifdef WITH_CXX_GUARDEDALLOC
 public:
diff --git a/source/gameengine/SceneGraph/SG_BBox.cpp b/source/gameengine/SceneGraph/SG_BBox.cpp
index b5618ebbf03..01107557481 100644
--- a/source/gameengine/SceneGraph/SG_BBox.cpp
+++ b/source/gameengine/SceneGraph/SG_BBox.cpp
@@ -142,8 +142,8 @@ SG_BBox SG_BBox::transform(const MT_Transform &world) const
 bool SG_BBox::inside(const MT_Point3 &point) const
 {
 	return point[0] >= m_min[0] && point[0] <= m_max[0] &&
-	    point[1] >= m_min[1] && point[1] <= m_max[1] &&
-	    point[2] >= m_min[2] && point[2] <= m_max[2];
+	        point[1] >= m_min[1] && point[1] <= m_max[1] &&
+	        point[2] >= m_min[2] && point[2] <= m_max[2];
 }
 
 bool SG_BBox::inside(const SG_BBox& other) const
diff --git a/source/gameengine/SceneGraph/SG_DList.h b/source/gameengine/SceneGraph/SG_DList.h
index b82e51e0d2f..9e7e514b27a 100644
--- a/source/gameengine/SceneGraph/SG_DList.h
+++ b/source/gameengine/SceneGraph/SG_DList.h
@@ -134,88 +134,88 @@ public:
 		}
 	};
 
-    SG_DList() 
-    { 
-        m_flink = m_blink = this; 
-    }
+	SG_DList()
+	{
+		m_flink = m_blink = this;
+	}
 	SG_DList(const SG_DList& other)
 	{
-        m_flink = m_blink = this; 
+		m_flink = m_blink = this;
 	}
-    virtual ~SG_DList() 
-    {
+	virtual ~SG_DList()
+	{
 		Delink();
-    }
+	}
 
-    inline bool Empty()               // Check for empty queue
-    {     
-        return ( m_flink == this ); 
-    }
-    bool AddBack( SG_DList *item )  // Add to the back
-    {
+	inline bool Empty()               // Check for empty queue
+	{
+		return ( m_flink == this );
+	}
+	bool AddBack( SG_DList *item )  // Add to the back
+	{
 		if (!item->Empty())
 			return false;
-        item->m_blink = m_blink;
-        item->m_flink = this;
-        m_blink->m_flink = item;
-        m_blink = item;
+		item->m_blink = m_blink;
+		item->m_flink = this;
+		m_blink->m_flink = item;
+		m_blink = item;
 		return true;
-    }
-    bool AddFront( SG_DList *item )  // Add to the back
-    {
+	}
+	bool AddFront( SG_DList *item )  // Add to the back
+	{
 		if (!item->Empty())
 			return false;
-        item->m_flink = m_flink;
-        item->m_blink = this;
-        m_flink->m_blink = item;
-        m_flink = item;
+		item->m_flink = m_flink;
+		item->m_blink = this;
+		m_flink->m_blink = item;
+		m_flink = item;
 		return true;
-    }
-    SG_DList *Remove()           // Remove from the front
-    {
-        if (Empty()) 
-        {
-            return NULL;
-        }
-        SG_DList* item = m_flink;
-        m_flink = item->m_flink;
-        m_flink->m_blink = this;
-        item->m_flink = item->m_blink = item;
-        return item;
-    }
-    bool Delink()             // Remove from the middle
-    {
+	}
+	SG_DList *Remove()           // Remove from the front
+	{
+		if (Empty())
+		{
+			return NULL;
+		}
+		SG_DList* item = m_flink;
+		m_flink = item->m_flink;
+		m_flink->m_blink = this;
+		item->m_flink = item->m_blink = item;
+		return item;
+	}
+	bool Delink()             // Remove from the middle
+	{
 		if (Empty())
 			return false;
 		m_blink->m_flink = m_flink;
 		m_flink->m_blink = m_blink;
 		m_flink = m_blink = this;
 		return true;
-    }
-    inline SG_DList *Peek()			// Look at front without removing
-    { 
-        return m_flink; 
-    }  
-    inline SG_DList *Back()			// Look at front without removing
-    { 
-        return m_blink; 
-    }  
-    inline SG_DList *Self() 
-    { 
-        return this; 
-    }
-    inline const SG_DList *Peek() const			// Look at front without removing
-    { 
-        return (const SG_DList*)m_flink; 
-    }  
-    inline const SG_DList *Back() const			// Look at front without removing
-    { 
-        return (const SG_DList*)m_blink; 
-    }  
-    inline const SG_DList *Self() const 
-    { 
-        return this; 
-    }
+	}
+	inline SG_DList *Peek()			// Look at front without removing
+	{
+		return m_flink;
+	}
+	inline SG_DList *Back()			// Look at front without removing
+	{
+		return m_blink;
+	}
+	inline SG_DList *Self()
+	{
+		return this;
+	}
+	inline const SG_DList *Peek() const			// Look at front without removing
+	{
+		return (const SG_DList*)m_flink;
+	}
+	inline const SG_DList *Back() const			// Look at front without removing
+	{
+		return (const SG_DList*)m_blink;
+	}
+	inline const SG_DList *Self() const
+	{
+		return this;
+	}
 	
 	
 #ifdef WITH_CXX_GUARDEDALLOC
diff --git a/source/gameengine/SceneGraph/SG_IObject.cpp b/source/gameengine/SceneGraph/SG_IObject.cpp
index 3064e6662b9..b22d210984d 100644
--- a/source/gameengine/SceneGraph/SG_IObject.cpp
+++ b/source/gameengine/SceneGraph/SG_IObject.cpp
@@ -34,6 +34,8 @@
 #include "SG_IObject.h"
 #include "SG_Controller.h"
 
+#include <algorithm>
+
 SG_Stage gSG_Stage = SG_STAGE_UNKNOWN;
 
 SG_IObject::
@@ -71,6 +73,16 @@ AddSGController(
 
 	void				
 SG_IObject::
+RemoveSGController(
+	SG_Controller* cont
+) {
+	SGControllerList::iterator contit;
+
+	m_SGcontrollers.erase(std::remove(m_SGcontrollers.begin(), m_SGcontrollers.end(), cont));
+}
+
+	void
+SG_IObject::
 RemoveAllControllers(
 ) { 
 	m_SGcontrollers.clear(); 
diff --git a/source/gameengine/SceneGraph/SG_IObject.h b/source/gameengine/SceneGraph/SG_IObject.h
index 26e317bdcd9..8c0159fe8d4 100644
--- a/source/gameengine/SceneGraph/SG_IObject.h
+++ b/source/gameengine/SceneGraph/SG_IObject.h
@@ -49,6 +49,7 @@ enum SG_Stage
 	SG_STAGE_CONTROLLER_UPDATE,
 	SG_STAGE_ACTUATOR,
 	SG_STAGE_ACTUATOR_UPDATE,
+	SG_STAGE_ANIMATION_UPDATE,
 	SG_STAGE_PHYSICS2,
 	SG_STAGE_PHYSICS2_UPDATE,
 	SG_STAGE_SCENE,
@@ -180,10 +181,20 @@ public:
 		SG_Controller* cont
 	);
 
+	/**
+	 * Remove a pointer to a controller from this node.
+	 * This does not delete the controller itself! Be careful to
+	 * avoid memory leaks.
+	 */
+		void
+	RemoveSGController(
+		SG_Controller* cont
+	);
+
 	/** 
 	 * Clear the array of pointers to controllers associated with 
 	 * this node. This does not delete the controllers themselves!
-     * This should be used very carefully to avoid memory
+	 * This should be used very carefully to avoid memory
 	 * leaks.
 	 */
 	
diff --git a/source/gameengine/SceneGraph/SG_QList.h b/source/gameengine/SceneGraph/SG_QList.h
index de79c35821e..eb404b1a5a5 100644
--- a/source/gameengine/SceneGraph/SG_QList.h
+++ b/source/gameengine/SceneGraph/SG_QList.h
@@ -91,73 +91,73 @@ public:
 	};
 
 	SG_QList() : SG_DList()
-    { 
-        m_fqlink = m_bqlink = this; 
-    }
+	{
+		m_fqlink = m_bqlink = this;
+	}
 	SG_QList(const SG_QList& other) : SG_DList()
 	{
-        m_fqlink = m_bqlink = this; 
+		m_fqlink = m_bqlink = this;
 	}
-    virtual ~SG_QList() 
-    {
+	virtual ~SG_QList()
+	{
 		QDelink();
-    }
+	}
 
-    inline bool QEmpty()               // Check for empty queue
-    {     
-        return ( m_fqlink == this ); 
-    }
-    bool QAddBack( SG_QList *item )  // Add to the back
-    {
+	inline bool QEmpty()               // Check for empty queue
+	{
+		return ( m_fqlink == this );
+	}
+	bool QAddBack( SG_QList *item )  // Add to the back
+	{
 		if (!item->QEmpty())
 			return false;
-        item->m_bqlink = m_bqlink;
-        item->m_fqlink = this;
-        m_bqlink->m_fqlink = item;
-        m_bqlink = item;
+		item->m_bqlink = m_bqlink;
+		item->m_fqlink = this;
+		m_bqlink->m_fqlink = item;
+		m_bqlink = item;
 		return true;
-    }
-    bool QAddFront( SG_QList *item )  // Add to the back
-    {
+	}
+	bool QAddFront( SG_QList *item )  // Add to the back
+	{
 		if (!item->Empty())
 			return false;
-        item->m_fqlink = m_fqlink;
-        item->m_bqlink = this;
-        m_fqlink->m_bqlink = item;
-        m_fqlink = item;
+		item->m_fqlink = m_fqlink;
+		item->m_bqlink = this;
+		m_fqlink->m_bqlink = item;
+		m_fqlink = item;
 		return true;
-    }
-    SG_QList *QRemove()           // Remove from the front
-    {
-        if (QEmpty()) 
-        {
-            return NULL;
-        }
-        SG_QList* item = m_fqlink;
-        m_fqlink = item->m_fqlink;
-        m_fqlink->m_bqlink = this;
-        item->m_fqlink = item->m_bqlink = item;
-        return item;
-    }
-    bool QDelink()             // Remove from the middle
-    {
+	}
+	SG_QList *QRemove()           // Remove from the front
+	{
+		if (QEmpty())
+		{
+			return NULL;
+		}
+		SG_QList* item = m_fqlink;
+		m_fqlink = item->m_fqlink;
+		m_fqlink->m_bqlink = this;
+		item->m_fqlink = item->m_bqlink = item;
+		return item;
+	}
+	bool QDelink()             // Remove from the middle
+	{
 		if (QEmpty())
 			return false;
 		m_bqlink->m_fqlink = m_fqlink;
 		m_fqlink->m_bqlink = m_bqlink;
 		m_fqlink = m_bqlink = this;
 		return true;
-    }
-    inline SG_QList *QPeek()			// Look at front without removing
-    { 
-        return m_fqlink; 
-    }  
-    inline SG_QList *QBack()			// Look at front without removing
-    { 
-        return m_bqlink; 
-    }  
-	
-	
+	}
+	inline SG_QList *QPeek()			// Look at front without removing
+	{
+		return m_fqlink;
+	}
+	inline SG_QList *QBack()			// Look at front without removing
+	{
+		return m_bqlink;
+	}
+
+
 #ifdef WITH_CXX_GUARDEDALLOC
 public:
 	void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_QList"); }
diff --git a/source/gameengine/SceneGraph/SG_Spatial.cpp b/source/gameengine/SceneGraph/SG_Spatial.cpp
index ca778d164c8..09fb7278bfa 100644
--- a/source/gameengine/SceneGraph/SG_Spatial.cpp
+++ b/source/gameengine/SceneGraph/SG_Spatial.cpp
@@ -109,18 +109,17 @@ SetParentRelation(
  */
 
 
-	bool 
+	bool
 SG_Spatial::
 UpdateSpatialData(
-	const SG_Spatial *parent,
-	double time,
-	bool& parentUpdated
-){
-
-    bool bComputesWorldTransform = false;
+	        const SG_Spatial *parent,
+	        double time,
+	        bool& parentUpdated
+	        ){
+	bool bComputesWorldTransform = false;
 
 	// update spatial controllers
-	
+
 	SGControllerList::iterator cit = GetSGControllerList().begin();
 	SGControllerList::const_iterator c_end = GetSGControllerList().end();
 
@@ -131,7 +130,7 @@ UpdateSpatialData(
 	}
 
 	// If none of the objects updated our values then we ask the
-	// parent_relation object owned by this class to update 
+	// parent_relation object owned by this class to update
 	// our world coordinates.
 
 	if (!bComputesWorldTransform)
diff --git a/source/gameengine/VideoTexture/CMakeLists.txt b/source/gameengine/VideoTexture/CMakeLists.txt
index 201714be74a..448fb307d2d 100644
--- a/source/gameengine/VideoTexture/CMakeLists.txt
+++ b/source/gameengine/VideoTexture/CMakeLists.txt
@@ -26,26 +26,26 @@
 
 set(INC
 	.
-	../../../source/gameengine/Ketsji
-	../../../source/gameengine/Expressions
-	../../../source/gameengine/GameLogic
-	../../../source/gameengine/SceneGraph
-	../../../source/gameengine/Rasterizer
-	../../../source/gameengine/Rasterizer/RAS_OpenGLRasterizer
-	../../../source/gameengine/BlenderRoutines
-	../../../source/blender/blenlib
-	../../../source/blender/blenkernel
-	../../../source/blender/makesdna
-	../../../source/blender/editors/include
-	../../../source/blender/imbuf
-	../../../source/blender/python
-	../../../source/blender/python/generic
-	../../../source/blender/gpu
+	../BlenderRoutines
+	../Expressions
+	../GameLogic
+	../Ketsji
+	../Rasterizer
+	../Rasterizer/RAS_OpenGLRasterizer
+	../SceneGraph
+	../../blender/blenkernel
+	../../blender/blenlib
+	../../blender/editors/include
+	../../blender/gpu
+	../../blender/imbuf
+	../../blender/makesdna
+	../../blender/python
+	../../blender/python/generic
 	../../../intern/container
-	../../../intern/string
-	../../../intern/moto/include
-	../../../intern/guardedalloc
 	../../../intern/ffmpeg
+	../../../intern/guardedalloc
+	../../../intern/moto/include
+	../../../intern/string
 )
 
 set(INC_SYS
@@ -91,11 +91,10 @@ set(SRC
 
 if(WITH_CODEC_FFMPEG)
 	list(APPEND INC_SYS
-		${FFMPEG_INC}
-		${PTHREADS_INC}
+		${FFMPEG_INCLUDE_DIRS}
+		${PTHREADS_INCLUDE_DIRS}
 	)
 	add_definitions(-DWITH_FFMPEG)
-	add_definitions(-D__STDC_CONSTANT_MACROS)
 endif()
 
 blender_add_lib(ge_videotex "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/gameengine/VideoTexture/Exception.cpp b/source/gameengine/VideoTexture/Exception.cpp
index 8c8258585a5..30a8af4b125 100644
--- a/source/gameengine/VideoTexture/Exception.cpp
+++ b/source/gameengine/VideoTexture/Exception.cpp
@@ -105,7 +105,7 @@ Exception::Exception (ExceptionID & expID, RESULT rslt, const char * fil, int li
 : m_expID (&expID), m_hRslt (rslt)
 {
 	// set file and line
-	if (strlen(fil) > 0 || lin > 0)
+	if (fil[0] != '\0' || lin > 0)
 		setFileLine (fil, lin);
 }
 
@@ -201,20 +201,20 @@ void Exception::copy (const Exception & xpt)
 
 void registerAllExceptions(void)
 {
-    errGenerDesc.registerDesc();
-    errNFoundDesc.registerDesc();
-    MaterialNotAvailDesc.registerDesc();
-    ImageSizesNotMatchDesc.registerDesc();
-    ImageHasExportsDesc.registerDesc();
+	errGenerDesc.registerDesc();
+	errNFoundDesc.registerDesc();
+	MaterialNotAvailDesc.registerDesc();
+	ImageSizesNotMatchDesc.registerDesc();
+	ImageHasExportsDesc.registerDesc();
 	InvalidColorChannelDesc.registerDesc();
-    SceneInvalidDesc.registerDesc();
-    CameraInvalidDesc.registerDesc();
-    ObserverInvalidDesc.registerDesc();
-    MirrorInvalidDesc.registerDesc();
-    MirrorSizeInvalidDesc.registerDesc();
-    MirrorNormalInvalidDesc.registerDesc();
-    MirrorHorizontalDesc.registerDesc();
-    MirrorTooSmallDesc.registerDesc();
-    SourceVideoEmptyDesc.registerDesc();
-    SourceVideoCreationDesc.registerDesc();
+	SceneInvalidDesc.registerDesc();
+	CameraInvalidDesc.registerDesc();
+	ObserverInvalidDesc.registerDesc();
+	MirrorInvalidDesc.registerDesc();
+	MirrorSizeInvalidDesc.registerDesc();
+	MirrorNormalInvalidDesc.registerDesc();
+	MirrorHorizontalDesc.registerDesc();
+	MirrorTooSmallDesc.registerDesc();
+	SourceVideoEmptyDesc.registerDesc();
+	SourceVideoCreationDesc.registerDesc();
 }
diff --git a/source/gameengine/VideoTexture/Exception.h b/source/gameengine/VideoTexture/Exception.h
index 16248186108..11e617cf4ce 100644
--- a/source/gameengine/VideoTexture/Exception.h
+++ b/source/gameengine/VideoTexture/Exception.h
@@ -122,11 +122,11 @@ public:
 		desc = m_description;
 	}
 
-    void registerDesc(void)
-    {
-        if (std::find(m_expDescs.begin(), m_expDescs.end(), this) == m_expDescs.end())
-            m_expDescs.push_back(this);
-    }
+	void registerDesc(void)
+	{
+		if (std::find(m_expDescs.begin(), m_expDescs.end(), this) == m_expDescs.end())
+			m_expDescs.push_back(this);
+	}
 	// list of exception descriptions
 	static std::vector<ExpDesc*> m_expDescs;
 
diff --git a/source/gameengine/VideoTexture/FilterColor.h b/source/gameengine/VideoTexture/FilterColor.h
index 2478727a6be..d0536ed2801 100644
--- a/source/gameengine/VideoTexture/FilterColor.h
+++ b/source/gameengine/VideoTexture/FilterColor.h
@@ -141,7 +141,7 @@ protected:
 	/// calculate one color component
 	unsigned int calcColor (unsigned int val, short idx)
 	{
-		unsigned int col = VT_C(val,idx);;
+		unsigned int col = VT_C(val,idx);
 		if (col <= levels[idx][0]) col = 0;
 		else if (col >= levels[idx][1]) col = 0xFF;
 		else col = (((col - levels[idx][0]) << 8) / levels[idx][2]) & 0xFF;
diff --git a/source/gameengine/VideoTexture/ImageBase.cpp b/source/gameengine/VideoTexture/ImageBase.cpp
index a70c56a070c..65509ab9424 100644
--- a/source/gameengine/VideoTexture/ImageBase.cpp
+++ b/source/gameengine/VideoTexture/ImageBase.cpp
@@ -375,7 +375,7 @@ void Image_dealloc (PyImage * self)
 		if (self->m_image->m_exports > 0)
 		{
 			PyErr_SetString(PyExc_SystemError,
-				            "deallocated Image object has exported buffers");
+			                "deallocated Image object has exported buffers");
 			PyErr_Print();
 		}
 		// if release requires deleting of object, do it
@@ -645,7 +645,7 @@ PyObject * Image_valid(PyImage * self, void * closure)
 int Image_getbuffer(PyImage *self, Py_buffer *view, int flags)
 {
 	unsigned int * image;
-    int ret;
+	int ret;
 
 	try
 	{
@@ -667,25 +667,25 @@ int Image_getbuffer(PyImage *self, Py_buffer *view, int flags)
 		//return -1;
 		goto error;
 	}
-    if (view == NULL) 
+	if (view == NULL)
 	{
-        self->m_image->m_exports++;
-        return 0;
-    }
-    ret = PyBuffer_FillInfo(view, (PyObject*)self, image, self->m_image->getBuffSize(), 0, flags);
-    if (ret >= 0)
-        self->m_image->m_exports++;
-    return ret;
+		self->m_image->m_exports++;
+		return 0;
+	}
+	ret = PyBuffer_FillInfo(view, (PyObject*)self, image, self->m_image->getBuffSize(), 0, flags);
+	if (ret >= 0)
+		self->m_image->m_exports++;
+	return ret;
 
 error:
 	// Return a empty buffer to avoid a crash in Python 3.1
 	// The bug is fixed in Python SVN 77916, as soon as the python revision used by Blender is
 	// updated, you can simply return -1 and set the error
 	static char* buf = (char *)"";
-    ret = PyBuffer_FillInfo(view, (PyObject*)self, buf, 0, 0, flags);
-    if (ret >= 0)
-        self->m_image->m_exports++;
-    return ret;
+	ret = PyBuffer_FillInfo(view, (PyObject*)self, buf, 0, 0, flags);
+	if (ret >= 0)
+		self->m_image->m_exports++;
+	return ret;
 	
 }
 
diff --git a/source/gameengine/VideoTexture/ImageMix.cpp b/source/gameengine/VideoTexture/ImageMix.cpp
index 7a8226aab03..aeef5d1694f 100644
--- a/source/gameengine/VideoTexture/ImageMix.cpp
+++ b/source/gameengine/VideoTexture/ImageMix.cpp
@@ -135,7 +135,7 @@ PyObject * setWeight (PyImage * self, PyObject * args)
 		if (!getImageMix(self)->setWeight(id, weight))
 		{
 			// if not set, report error
-			PyErr_SetString(PyExc_RuntimeError, "Invalid id of source");;
+			PyErr_SetString(PyExc_RuntimeError, "Invalid id of source");
 			return NULL;
 		}
 	// return none
diff --git a/source/gameengine/VideoTexture/ImageRender.cpp b/source/gameengine/VideoTexture/ImageRender.cpp
index 6038416ba68..f7546d876b2 100644
--- a/source/gameengine/VideoTexture/ImageRender.cpp
+++ b/source/gameengine/VideoTexture/ImageRender.cpp
@@ -65,29 +65,29 @@ ImageRender::ImageRender (KX_Scene * scene, KX_Camera * camera) :
     m_owncamera(false),
     m_observer(NULL),
     m_mirror(NULL),
-	m_clip(100.f)
+    m_clip(100.f)
 {
 	// initialize background color
 	setBackground(0, 0, 255, 255);
-    // retrieve rendering objects
-    m_engine = KX_GetActiveEngine();
-    m_rasterizer = m_engine->GetRasterizer();
-    m_canvas = m_engine->GetCanvas();
-    m_rendertools = m_engine->GetRenderTools();
+	// retrieve rendering objects
+	m_engine = KX_GetActiveEngine();
+	m_rasterizer = m_engine->GetRasterizer();
+	m_canvas = m_engine->GetCanvas();
+	m_rendertools = m_engine->GetRenderTools();
 }
 
 // destructor
 ImageRender::~ImageRender (void)
 {
-    if (m_owncamera)
-        m_camera->Release();
+	if (m_owncamera)
+		m_camera->Release();
 }
 
 
 // set background color
 void ImageRender::setBackground (int red, int green, int blue, int alpha)
 {
-    m_background[0] = (red < 0) ? 0.f : (red > 255) ? 1.f : float(red)/255.f;
+	m_background[0] = (red < 0) ? 0.f : (red > 255) ? 1.f : float(red)/255.f;
 	m_background[1] = (green < 0) ? 0.f : (green > 255) ? 1.f : float(green)/255.f;
 	m_background[2] = (blue < 0) ? 0.f : (blue > 255) ? 1.f : float(blue)/255.f;
 	m_background[3] = (alpha < 0) ? 0.f : (alpha > 255) ? 1.f : float(alpha)/255.f;
@@ -97,157 +97,157 @@ void ImageRender::setBackground (int red, int green, int blue, int alpha)
 // capture image from viewport
 void ImageRender::calcImage (unsigned int texId, double ts)
 {
-    if (m_rasterizer->GetDrawingMode() != RAS_IRasterizer::KX_TEXTURED ||   // no need for texture
-        m_camera->GetViewport() ||        // camera must be inactive
-        m_camera == m_scene->GetActiveCamera())
-    {
-        // no need to compute texture in non texture rendering
-        m_avail = false;
-        return;
-    }
-    // render the scene from the camera
-    Render();
+	if (m_rasterizer->GetDrawingMode() != RAS_IRasterizer::KX_TEXTURED ||   // no need for texture
+	        m_camera->GetViewport() ||        // camera must be inactive
+	        m_camera == m_scene->GetActiveCamera())
+	{
+		// no need to compute texture in non texture rendering
+		m_avail = false;
+		return;
+	}
+	// render the scene from the camera
+	Render();
 	// get image from viewport
 	ImageViewport::calcImage(texId, ts);
-    // restore OpenGL state
-    m_canvas->EndFrame();
+	// restore OpenGL state
+	m_canvas->EndFrame();
 }
 
 void ImageRender::Render()
 {
 	RAS_FrameFrustum frustrum;
 
-    if (!m_render)
-        return;
-
-    if (m_mirror)
-    {
-        // mirror mode, compute camera frustrum, position and orientation
-        // convert mirror position and normal in world space
-        const MT_Matrix3x3 & mirrorObjWorldOri = m_mirror->GetSGNode()->GetWorldOrientation();
-        const MT_Point3 & mirrorObjWorldPos = m_mirror->GetSGNode()->GetWorldPosition();
-        const MT_Vector3 & mirrorObjWorldScale = m_mirror->GetSGNode()->GetWorldScaling();
-        MT_Point3 mirrorWorldPos = 
-            mirrorObjWorldPos + mirrorObjWorldScale * (mirrorObjWorldOri * m_mirrorPos);
-        MT_Vector3 mirrorWorldZ = mirrorObjWorldOri * m_mirrorZ;
-        // get observer world position
-        const MT_Point3 & observerWorldPos = m_observer->GetSGNode()->GetWorldPosition();
-        // get plane D term = mirrorPos . normal
-        MT_Scalar mirrorPlaneDTerm = mirrorWorldPos.dot(mirrorWorldZ);
-        // compute distance of observer to mirror = D - observerPos . normal
-        MT_Scalar observerDistance = mirrorPlaneDTerm - observerWorldPos.dot(mirrorWorldZ);
-        // if distance < 0.01 => observer is on wrong side of mirror, don't render
-        if (observerDistance < 0.01f)
-            return;
-        // set camera world position = observerPos + normal * 2 * distance
-        MT_Point3 cameraWorldPos = observerWorldPos + (MT_Scalar(2.0)*observerDistance)*mirrorWorldZ;
-        m_camera->GetSGNode()->SetLocalPosition(cameraWorldPos);
-        // set camera orientation: z=normal, y=mirror_up in world space, x= y x z
-        MT_Vector3 mirrorWorldY = mirrorObjWorldOri * m_mirrorY;
-        MT_Vector3 mirrorWorldX = mirrorObjWorldOri * m_mirrorX;
-        MT_Matrix3x3 cameraWorldOri(
-            mirrorWorldX[0], mirrorWorldY[0], mirrorWorldZ[0],
-            mirrorWorldX[1], mirrorWorldY[1], mirrorWorldZ[1], 
-            mirrorWorldX[2], mirrorWorldY[2], mirrorWorldZ[2]);
-        m_camera->GetSGNode()->SetLocalOrientation(cameraWorldOri);
-        m_camera->GetSGNode()->UpdateWorldData(0.0);
-        // compute camera frustrum:
-        //   get position of mirror relative to camera: offset = mirrorPos-cameraPos
-        MT_Vector3 mirrorOffset = mirrorWorldPos - cameraWorldPos;
-        //   convert to camera orientation
-        mirrorOffset = mirrorOffset * cameraWorldOri;
-        //   scale mirror size to world scale: 
-        //     get closest local axis for mirror Y and X axis and scale height and width by local axis scale
-        MT_Scalar x, y;
-        x = fabs(m_mirrorY[0]);
-        y = fabs(m_mirrorY[1]);
-        float height = (x > y) ? 
-            ((x > fabs(m_mirrorY[2])) ? mirrorObjWorldScale[0] : mirrorObjWorldScale[2]):
-            ((y > fabs(m_mirrorY[2])) ? mirrorObjWorldScale[1] : mirrorObjWorldScale[2]);
-        x = fabs(m_mirrorX[0]);
-        y = fabs(m_mirrorX[1]);
-        float width = (x > y) ? 
-            ((x > fabs(m_mirrorX[2])) ? mirrorObjWorldScale[0] : mirrorObjWorldScale[2]):
-            ((y > fabs(m_mirrorX[2])) ? mirrorObjWorldScale[1] : mirrorObjWorldScale[2]);
-        width *= m_mirrorHalfWidth;
-        height *= m_mirrorHalfHeight;
-        //   left = offsetx-width
-        //   right = offsetx+width
-        //   top = offsety+height
-        //   bottom = offsety-height
-        //   near = -offsetz
-        //   far = near+100
-        frustrum.x1 = mirrorOffset[0]-width;
-        frustrum.x2 = mirrorOffset[0]+width;
-        frustrum.y1 = mirrorOffset[1]-height;
-        frustrum.y2 = mirrorOffset[1]+height;
-        frustrum.camnear = -mirrorOffset[2];
-        frustrum.camfar = -mirrorOffset[2]+m_clip;
-    }
+	if (!m_render)
+		return;
+
+	if (m_mirror)
+	{
+		// mirror mode, compute camera frustrum, position and orientation
+		// convert mirror position and normal in world space
+		const MT_Matrix3x3 & mirrorObjWorldOri = m_mirror->GetSGNode()->GetWorldOrientation();
+		const MT_Point3 & mirrorObjWorldPos = m_mirror->GetSGNode()->GetWorldPosition();
+		const MT_Vector3 & mirrorObjWorldScale = m_mirror->GetSGNode()->GetWorldScaling();
+		MT_Point3 mirrorWorldPos =
+		        mirrorObjWorldPos + mirrorObjWorldScale * (mirrorObjWorldOri * m_mirrorPos);
+		MT_Vector3 mirrorWorldZ = mirrorObjWorldOri * m_mirrorZ;
+		// get observer world position
+		const MT_Point3 & observerWorldPos = m_observer->GetSGNode()->GetWorldPosition();
+		// get plane D term = mirrorPos . normal
+		MT_Scalar mirrorPlaneDTerm = mirrorWorldPos.dot(mirrorWorldZ);
+		// compute distance of observer to mirror = D - observerPos . normal
+		MT_Scalar observerDistance = mirrorPlaneDTerm - observerWorldPos.dot(mirrorWorldZ);
+		// if distance < 0.01 => observer is on wrong side of mirror, don't render
+		if (observerDistance < 0.01f)
+			return;
+		// set camera world position = observerPos + normal * 2 * distance
+		MT_Point3 cameraWorldPos = observerWorldPos + (MT_Scalar(2.0)*observerDistance)*mirrorWorldZ;
+		m_camera->GetSGNode()->SetLocalPosition(cameraWorldPos);
+		// set camera orientation: z=normal, y=mirror_up in world space, x= y x z
+		MT_Vector3 mirrorWorldY = mirrorObjWorldOri * m_mirrorY;
+		MT_Vector3 mirrorWorldX = mirrorObjWorldOri * m_mirrorX;
+		MT_Matrix3x3 cameraWorldOri(
+		            mirrorWorldX[0], mirrorWorldY[0], mirrorWorldZ[0],
+		            mirrorWorldX[1], mirrorWorldY[1], mirrorWorldZ[1],
+		            mirrorWorldX[2], mirrorWorldY[2], mirrorWorldZ[2]);
+		m_camera->GetSGNode()->SetLocalOrientation(cameraWorldOri);
+		m_camera->GetSGNode()->UpdateWorldData(0.0);
+		// compute camera frustrum:
+		//   get position of mirror relative to camera: offset = mirrorPos-cameraPos
+		MT_Vector3 mirrorOffset = mirrorWorldPos - cameraWorldPos;
+		//   convert to camera orientation
+		mirrorOffset = mirrorOffset * cameraWorldOri;
+		//   scale mirror size to world scale:
+		//     get closest local axis for mirror Y and X axis and scale height and width by local axis scale
+		MT_Scalar x, y;
+		x = fabs(m_mirrorY[0]);
+		y = fabs(m_mirrorY[1]);
+		float height = (x > y) ?
+		            ((x > fabs(m_mirrorY[2])) ? mirrorObjWorldScale[0] : mirrorObjWorldScale[2]):
+		            ((y > fabs(m_mirrorY[2])) ? mirrorObjWorldScale[1] : mirrorObjWorldScale[2]);
+		x = fabs(m_mirrorX[0]);
+		y = fabs(m_mirrorX[1]);
+		float width = (x > y) ?
+		            ((x > fabs(m_mirrorX[2])) ? mirrorObjWorldScale[0] : mirrorObjWorldScale[2]):
+		            ((y > fabs(m_mirrorX[2])) ? mirrorObjWorldScale[1] : mirrorObjWorldScale[2]);
+		width *= m_mirrorHalfWidth;
+		height *= m_mirrorHalfHeight;
+		//   left = offsetx-width
+		//   right = offsetx+width
+		//   top = offsety+height
+		//   bottom = offsety-height
+		//   near = -offsetz
+		//   far = near+100
+		frustrum.x1 = mirrorOffset[0]-width;
+		frustrum.x2 = mirrorOffset[0]+width;
+		frustrum.y1 = mirrorOffset[1]-height;
+		frustrum.y2 = mirrorOffset[1]+height;
+		frustrum.camnear = -mirrorOffset[2];
+		frustrum.camfar = -mirrorOffset[2]+m_clip;
+	}
 	// Store settings to be restored later
-    const RAS_IRasterizer::StereoMode stereomode = m_rasterizer->GetStereoMode();
+	const RAS_IRasterizer::StereoMode stereomode = m_rasterizer->GetStereoMode();
 	RAS_Rect area = m_canvas->GetWindowArea();
 
-    // The screen area that ImageViewport will copy is also the rendering zone
-    m_canvas->SetViewPort(m_position[0], m_position[1], m_position[0]+m_capSize[0]-1, m_position[1]+m_capSize[1]-1);
-    m_canvas->ClearColor(m_background[0], m_background[1], m_background[2], m_background[3]);
-    m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER);
-    m_rasterizer->BeginFrame(RAS_IRasterizer::KX_TEXTURED,m_engine->GetClockTime());
-    m_rendertools->BeginFrame(m_rasterizer);
-    m_engine->SetWorldSettings(m_scene->GetWorldInfo());
-    m_rendertools->SetAuxilaryClientInfo(m_scene);
-    m_rasterizer->DisplayFog();
-    // matrix calculation, don't apply any of the stereo mode
-    m_rasterizer->SetStereoMode(RAS_IRasterizer::RAS_STEREO_NOSTEREO);
-    if (m_mirror)
-    {
-        // frustrum was computed above
-        // get frustrum matrix and set projection matrix
+	// The screen area that ImageViewport will copy is also the rendering zone
+	m_canvas->SetViewPort(m_position[0], m_position[1], m_position[0]+m_capSize[0]-1, m_position[1]+m_capSize[1]-1);
+	m_canvas->ClearColor(m_background[0], m_background[1], m_background[2], m_background[3]);
+	m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER);
+	m_rasterizer->BeginFrame(RAS_IRasterizer::KX_TEXTURED,m_engine->GetClockTime());
+	m_rendertools->BeginFrame(m_rasterizer);
+	m_engine->SetWorldSettings(m_scene->GetWorldInfo());
+	m_rendertools->SetAuxilaryClientInfo(m_scene);
+	m_rasterizer->DisplayFog();
+	// matrix calculation, don't apply any of the stereo mode
+	m_rasterizer->SetStereoMode(RAS_IRasterizer::RAS_STEREO_NOSTEREO);
+	if (m_mirror)
+	{
+		// frustrum was computed above
+		// get frustrum matrix and set projection matrix
 		MT_Matrix4x4 projmat = m_rasterizer->GetFrustumMatrix(
-			frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
+		            frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
 
 		m_camera->SetProjectionMatrix(projmat);
-    } else if (m_camera->hasValidProjectionMatrix())
+	} else if (m_camera->hasValidProjectionMatrix())
 	{
 		m_rasterizer->SetProjectionMatrix(m_camera->GetProjectionMatrix());
-    } else 
-    {
+	} else
+	{
 		float lens = m_camera->GetLens();
 		bool orthographic = !m_camera->GetCameraData()->m_perspective;
 		float nearfrust = m_camera->GetCameraNear();
 		float farfrust = m_camera->GetCameraFar();
-        float aspect_ratio = 1.0f;
-        Scene *blenderScene = m_scene->GetBlenderScene();
+		float aspect_ratio = 1.0f;
+		Scene *blenderScene = m_scene->GetBlenderScene();
 		MT_Matrix4x4 projmat;
 
 		// compute the aspect ratio from frame blender scene settings so that render to texture
-        // works the same in Blender and in Blender player
-        if (blenderScene->r.ysch != 0)
-            aspect_ratio = float(blenderScene->r.xsch*blenderScene->r.xasp) / float(blenderScene->r.ysch*blenderScene->r.yasp);
+		// works the same in Blender and in Blender player
+		if (blenderScene->r.ysch != 0)
+			aspect_ratio = float(blenderScene->r.xsch*blenderScene->r.xasp) / float(blenderScene->r.ysch*blenderScene->r.yasp);
 
 		if (orthographic) {
 
 			RAS_FramingManager::ComputeDefaultOrtho(
-				nearfrust,
-				farfrust,
-				m_camera->GetScale(),
-				aspect_ratio,
-				frustrum
-			);
+			            nearfrust,
+			            farfrust,
+			            m_camera->GetScale(),
+			            aspect_ratio,
+			            frustrum
+			            );
 
 			projmat = m_rasterizer->GetOrthoMatrix(
-				frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
-		} else 
+			            frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
+		} else
 		{
 			RAS_FramingManager::ComputeDefaultFrustum(
-				nearfrust,
-				farfrust,
-				lens,
-				aspect_ratio,
-				frustrum);
+			            nearfrust,
+			            farfrust,
+			            lens,
+			            aspect_ratio,
+			            frustrum);
 			
 			projmat = m_rasterizer->GetFrustumMatrix(
-				frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
+			            frustrum.x1, frustrum.x2, frustrum.y1, frustrum.y2, frustrum.camnear, frustrum.camfar);
 		}
 		m_camera->SetProjectionMatrix(projmat);
 	}
@@ -257,8 +257,8 @@ void ImageRender::Render()
 	
 	m_rasterizer->SetViewMatrix(viewmat, m_camera->NodeGetWorldOrientation(), m_camera->NodeGetWorldPosition(), m_camera->GetCameraData()->m_perspective);
 	m_camera->SetModelviewMatrix(viewmat);
-    // restore the stereo mode now that the matrix is computed
-    m_rasterizer->SetStereoMode(stereomode);
+	// restore the stereo mode now that the matrix is computed
+	m_rasterizer->SetStereoMode(stereomode);
 
 	m_scene->CalculateVisibleMeshes(m_rasterizer,m_camera);
 
@@ -328,11 +328,11 @@ static int ImageRender_init (PyObject * pySelf, PyObject * args, PyObject * kwds
 // get background color
 PyObject * getBackground (PyImage * self, void * closure)
 {
-	return Py_BuildValue("[BBBB]", 
-        getImageRender(self)->getBackground(0),
-		getImageRender(self)->getBackground(1), 
-        getImageRender(self)->getBackground(2),
-        getImageRender(self)->getBackground(3));
+	return Py_BuildValue("[BBBB]",
+	                     getImageRender(self)->getBackground(0),
+	                     getImageRender(self)->getBackground(1),
+	                     getImageRender(self)->getBackground(2),
+	                     getImageRender(self)->getBackground(3));
 }
 
 // set color
@@ -433,24 +433,24 @@ static int ImageMirror_init (PyObject * pySelf, PyObject * args, PyObject * kwds
 	PyObject * scene;
 	// reference object for mirror
 	PyObject * observer;
-    // object holding the mirror
-    PyObject * mirror;
-    // material of the mirror
-    short materialID = 0;
+	// object holding the mirror
+	PyObject * mirror;
+	// material of the mirror
+	short materialID = 0;
 	// parameter keywords
 	static const char *kwlist[] = {"scene", "observer", "mirror", "material", NULL};
 	// get parameters
 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOO|h",
-		const_cast<char**>(kwlist), &scene, &observer, &mirror, &materialID))
+	                                 const_cast<char**>(kwlist), &scene, &observer, &mirror, &materialID))
 		return -1;
 	try
 	{
 		// get scene pointer
 		KX_Scene * scenePtr (NULL);
-        if (scene != NULL && PyObject_TypeCheck(scene, &KX_Scene::Type))
-            scenePtr = static_cast<KX_Scene*>BGE_PROXY_REF(scene);
+		if (scene != NULL && PyObject_TypeCheck(scene, &KX_Scene::Type))
+			scenePtr = static_cast<KX_Scene*>BGE_PROXY_REF(scene);
 		else
-            THRWEXCP(SceneInvalid, S_OK);
+			THRWEXCP(SceneInvalid, S_OK);
 		
 		if(scenePtr==NULL) /* incase the python proxy reference is invalid */
 			THRWEXCP(SceneInvalid, S_OK);
@@ -458,11 +458,11 @@ static int ImageMirror_init (PyObject * pySelf, PyObject * args, PyObject * kwds
 		// get observer pointer
 		KX_GameObject * observerPtr (NULL);
 		if (observer != NULL && PyObject_TypeCheck(observer, &KX_GameObject::Type))
-            observerPtr = static_cast<KX_GameObject*>BGE_PROXY_REF(observer);
-        else if (observer != NULL && PyObject_TypeCheck(observer, &KX_Camera::Type))
-            observerPtr = static_cast<KX_Camera*>BGE_PROXY_REF(observer);
+			observerPtr = static_cast<KX_GameObject*>BGE_PROXY_REF(observer);
+		else if (observer != NULL && PyObject_TypeCheck(observer, &KX_Camera::Type))
+			observerPtr = static_cast<KX_Camera*>BGE_PROXY_REF(observer);
 		else
-            THRWEXCP(ObserverInvalid, S_OK);
+			THRWEXCP(ObserverInvalid, S_OK);
 		
 		if(observerPtr==NULL) /* incase the python proxy reference is invalid */
 			THRWEXCP(ObserverInvalid, S_OK);
@@ -470,27 +470,27 @@ static int ImageMirror_init (PyObject * pySelf, PyObject * args, PyObject * kwds
 		// get mirror pointer
 		KX_GameObject * mirrorPtr (NULL);
 		if (mirror != NULL && PyObject_TypeCheck(mirror, &KX_GameObject::Type))
-            mirrorPtr = static_cast<KX_GameObject*>BGE_PROXY_REF(mirror);
+			mirrorPtr = static_cast<KX_GameObject*>BGE_PROXY_REF(mirror);
 		else
-            THRWEXCP(MirrorInvalid, S_OK);
+			THRWEXCP(MirrorInvalid, S_OK);
 		
 		if(mirrorPtr==NULL) /* incase the python proxy reference is invalid */
 			THRWEXCP(MirrorInvalid, S_OK);
 
-        // locate the material in the mirror
+		// locate the material in the mirror
 		RAS_IPolyMaterial * material = getMaterial(mirror, materialID);
 		if (material == NULL)
-            THRWEXCP(MaterialNotAvail, S_OK);
+			THRWEXCP(MaterialNotAvail, S_OK);
 
 		// get pointer to image structure
 		PyImage * self = reinterpret_cast<PyImage*>(pySelf);
 
 		// create source object
-		if (self->m_image != NULL) 
-        {
-            delete self->m_image;
-            self->m_image = NULL;
-        }
+		if (self->m_image != NULL)
+		{
+			delete self->m_image;
+			self->m_image = NULL;
+		}
 		self->m_image = new ImageRender(scenePtr, observerPtr, mirrorPtr, material);
 	}
 	catch (Exception & exp)
@@ -530,7 +530,7 @@ static PyGetSetDef imageMirrorGetSets[] =
 	{(char*)"clip", (getter)getClip, (setter)setClip, (char*)"clipping distance", NULL},
 	// attribute from ImageRender
 	{(char*)"background", (getter)getBackground, (setter)setBackground, (char*)"background color", NULL},
-    // attribute from ImageViewport
+	// attribute from ImageViewport
 	{(char*)"capsize", (getter)ImageViewport_getCaptureSize, (setter)ImageViewport_setCaptureSize, (char*)"size of render area", NULL},
 	{(char*)"alpha", (getter)ImageViewport_getAlpha, (setter)ImageViewport_setAlpha, (char*)"use alpha in texture", NULL},
 	{(char*)"whole", (getter)ImageViewport_getWhole, (setter)ImageViewport_setWhole, (char*)"use whole viewport to render", NULL},
@@ -552,164 +552,164 @@ ImageRender::ImageRender (KX_Scene * scene, KX_GameObject * observer, KX_GameObj
     m_scene(scene),
     m_observer(observer),
     m_mirror(mirror),
-	m_clip(100.f)
+    m_clip(100.f)
 {
-    // this constructor is used for automatic planar mirror
-    // create a camera, take all data by default, in any case we will recompute the frustrum on each frame
+	// this constructor is used for automatic planar mirror
+	// create a camera, take all data by default, in any case we will recompute the frustrum on each frame
 	RAS_CameraData camdata;
-    vector<RAS_TexVert*> mirrorVerts;
-    vector<RAS_TexVert*>::iterator it;
-    float mirrorArea = 0.f;
-    float mirrorNormal[3] = {0.f, 0.f, 0.f};
-    float mirrorUp[3];
-    float dist, vec[3], axis[3];
-    float zaxis[3] = {0.f, 0.f, 1.f};
-    float yaxis[3] = {0.f, 1.f, 0.f};
-    float mirrorMat[3][3];
-    float left, right, top, bottom, back;
+	vector<RAS_TexVert*> mirrorVerts;
+	vector<RAS_TexVert*>::iterator it;
+	float mirrorArea = 0.f;
+	float mirrorNormal[3] = {0.f, 0.f, 0.f};
+	float mirrorUp[3];
+	float dist, vec[3], axis[3];
+	float zaxis[3] = {0.f, 0.f, 1.f};
+	float yaxis[3] = {0.f, 1.f, 0.f};
+	float mirrorMat[3][3];
+	float left, right, top, bottom, back;
 	// make sure this camera will delete its node
 	m_camera= new KX_Camera(scene, KX_Scene::m_callbacks, camdata, true, true);
 	m_camera->SetName("__mirror__cam__");
-    // don't add the camera to the scene object list, it doesn't need to be accessible
-    m_owncamera = true;
-    // retrieve rendering objects
-    m_engine = KX_GetActiveEngine();
-    m_rasterizer = m_engine->GetRasterizer();
-    m_canvas = m_engine->GetCanvas();
-    m_rendertools = m_engine->GetRenderTools();
-    // locate the vertex assigned to mat and do following calculation in mesh coordinates
-    for (int meshIndex = 0; meshIndex < mirror->GetMeshCount(); meshIndex++)
-    {
-        RAS_MeshObject*	mesh = mirror->GetMesh(meshIndex);
-        int numPolygons = mesh->NumPolygons();
-        for (int polygonIndex=0; polygonIndex < numPolygons; polygonIndex++)
-        {
-            RAS_Polygon* polygon = mesh->GetPolygon(polygonIndex);
-            if (polygon->GetMaterial()->GetPolyMaterial() == mat)
-            {
-                RAS_TexVert *v1, *v2, *v3, *v4;
-                float normal[3];
-                float area;
-                // this polygon is part of the mirror,
-                v1 = polygon->GetVertex(0);
-                v2 = polygon->GetVertex(1);
-                v3 = polygon->GetVertex(2);
-                mirrorVerts.push_back(v1);
-                mirrorVerts.push_back(v2);
-                mirrorVerts.push_back(v3);
-                if (polygon->VertexCount() == 4) 
-                {
-                    v4 = polygon->GetVertex(3);
-                    mirrorVerts.push_back(v4);
-                    area = normal_quad_v3( normal,(float*)v1->getXYZ(), (float*)v2->getXYZ(), (float*)v3->getXYZ(), (float*)v4->getXYZ());
-                } else
-                {
-                    area = normal_tri_v3( normal,(float*)v1->getXYZ(), (float*)v2->getXYZ(), (float*)v3->getXYZ());
-                }
-                area = fabs(area);
-                mirrorArea += area;
-                mul_v3_fl(normal, area);
-                add_v3_v3v3(mirrorNormal, mirrorNormal, normal);
-            }
-        }
-    }
-    if (mirrorVerts.size() == 0 || mirrorArea < FLT_EPSILON)
-    {
-        // no vertex or zero size mirror
-       THRWEXCP(MirrorSizeInvalid, S_OK);
-    }
-    // compute average normal of mirror faces
-    mul_v3_fl(mirrorNormal, 1.0f/mirrorArea);
-    if (normalize_v3(mirrorNormal) == 0.f)
-    {
-        // no normal
-        THRWEXCP(MirrorNormalInvalid, S_OK);
-    }
-    // the mirror plane has an equation of the type ax+by+cz = d where (a,b,c) is the normal vector
+	// don't add the camera to the scene object list, it doesn't need to be accessible
+	m_owncamera = true;
+	// retrieve rendering objects
+	m_engine = KX_GetActiveEngine();
+	m_rasterizer = m_engine->GetRasterizer();
+	m_canvas = m_engine->GetCanvas();
+	m_rendertools = m_engine->GetRenderTools();
+	// locate the vertex assigned to mat and do following calculation in mesh coordinates
+	for (int meshIndex = 0; meshIndex < mirror->GetMeshCount(); meshIndex++)
+	{
+		RAS_MeshObject*	mesh = mirror->GetMesh(meshIndex);
+		int numPolygons = mesh->NumPolygons();
+		for (int polygonIndex=0; polygonIndex < numPolygons; polygonIndex++)
+		{
+			RAS_Polygon* polygon = mesh->GetPolygon(polygonIndex);
+			if (polygon->GetMaterial()->GetPolyMaterial() == mat)
+			{
+				RAS_TexVert *v1, *v2, *v3, *v4;
+				float normal[3];
+				float area;
+				// this polygon is part of the mirror,
+				v1 = polygon->GetVertex(0);
+				v2 = polygon->GetVertex(1);
+				v3 = polygon->GetVertex(2);
+				mirrorVerts.push_back(v1);
+				mirrorVerts.push_back(v2);
+				mirrorVerts.push_back(v3);
+				if (polygon->VertexCount() == 4)
+				{
+					v4 = polygon->GetVertex(3);
+					mirrorVerts.push_back(v4);
+					area = normal_quad_v3( normal,(float*)v1->getXYZ(), (float*)v2->getXYZ(), (float*)v3->getXYZ(), (float*)v4->getXYZ());
+				} else
+				{
+					area = normal_tri_v3( normal,(float*)v1->getXYZ(), (float*)v2->getXYZ(), (float*)v3->getXYZ());
+				}
+				area = fabs(area);
+				mirrorArea += area;
+				mul_v3_fl(normal, area);
+				add_v3_v3v3(mirrorNormal, mirrorNormal, normal);
+			}
+		}
+	}
+	if (mirrorVerts.size() == 0 || mirrorArea < FLT_EPSILON)
+	{
+		// no vertex or zero size mirror
+		THRWEXCP(MirrorSizeInvalid, S_OK);
+	}
+	// compute average normal of mirror faces
+	mul_v3_fl(mirrorNormal, 1.0f/mirrorArea);
+	if (normalize_v3(mirrorNormal) == 0.f)
+	{
+		// no normal
+		THRWEXCP(MirrorNormalInvalid, S_OK);
+	}
+	// the mirror plane has an equation of the type ax+by+cz = d where (a,b,c) is the normal vector
 	// if the mirror is more vertical then horizontal, the Z axis is the up direction.
 	// otherwise the Y axis is the up direction.
 	// If the mirror is not perfectly vertical(horizontal), the Z(Y) axis projection on the mirror
 	// plan by the normal will be the up direction.
 	if (fabs(mirrorNormal[2]) > fabs(mirrorNormal[1]) &&
-		fabs(mirrorNormal[2]) > fabs(mirrorNormal[0]))
+	        fabs(mirrorNormal[2]) > fabs(mirrorNormal[0]))
 	{
 		// the mirror is more horizontal than vertical
-        copy_v3_v3(axis, yaxis);
+		copy_v3_v3(axis, yaxis);
 	}
 	else
 	{
 		// the mirror is more vertical than horizontal
-        copy_v3_v3(axis, zaxis);
+		copy_v3_v3(axis, zaxis);
+	}
+	dist = dot_v3v3(mirrorNormal, axis);
+	if (fabs(dist) < FLT_EPSILON)
+	{
+		// the mirror is already fully aligned with up axis
+		copy_v3_v3(mirrorUp, axis);
+	}
+	else
+	{
+		// projection of axis to mirror plane through normal
+		copy_v3_v3(vec, mirrorNormal);
+		mul_v3_fl(vec, dist);
+		sub_v3_v3v3(mirrorUp, axis, vec);
+		if (normalize_v3(mirrorUp) == 0.f)
+		{
+			// should not happen
+			THRWEXCP(MirrorHorizontal, S_OK);
+			return;
+		}
+	}
+	// compute rotation matrix between local coord and mirror coord
+	// to match camera orientation, we select mirror z = -normal, y = up, x = y x z
+	negate_v3_v3(mirrorMat[2], mirrorNormal);
+	copy_v3_v3(mirrorMat[1], mirrorUp);
+	cross_v3_v3v3(mirrorMat[0], mirrorMat[1], mirrorMat[2]);
+	// transpose to make it a orientation matrix from local space to mirror space
+	transpose_m3(mirrorMat);
+	// transform all vertex to plane coordinates and determine mirror position
+	left = FLT_MAX;
+	right = -FLT_MAX;
+	bottom = FLT_MAX;
+	top = -FLT_MAX;
+	back = -FLT_MAX; // most backward vertex (=highest Z coord in mirror space)
+	for (it = mirrorVerts.begin(); it != mirrorVerts.end(); it++)
+	{
+		copy_v3_v3(vec, (float*)(*it)->getXYZ());
+		mul_m3_v3(mirrorMat, vec);
+		if (vec[0] < left)
+			left = vec[0];
+		if (vec[0] > right)
+			right = vec[0];
+		if (vec[1] < bottom)
+			bottom = vec[1];
+		if (vec[1] > top)
+			top = vec[1];
+		if (vec[2] > back)
+			back = vec[2];
+	}
+	// now store this information in the object for later rendering
+	m_mirrorHalfWidth = (right-left)*0.5f;
+	m_mirrorHalfHeight = (top-bottom)*0.5f;
+	if (m_mirrorHalfWidth < 0.01f || m_mirrorHalfHeight < 0.01f)
+	{
+		// mirror too small
+		THRWEXCP(MirrorTooSmall, S_OK);
 	}
-    dist = dot_v3v3(mirrorNormal, axis);
-    if (fabs(dist) < FLT_EPSILON)
-    {
-        // the mirror is already fully aligned with up axis
-        copy_v3_v3(mirrorUp, axis);
-    }
-    else
-    {
-        // projection of axis to mirror plane through normal
-        copy_v3_v3(vec, mirrorNormal);
-        mul_v3_fl(vec, dist);
-        sub_v3_v3v3(mirrorUp, axis, vec);
-        if (normalize_v3(mirrorUp) == 0.f)
-        {
-            // should not happen
-            THRWEXCP(MirrorHorizontal, S_OK);
-            return;
-        }
-    }
-    // compute rotation matrix between local coord and mirror coord
-    // to match camera orientation, we select mirror z = -normal, y = up, x = y x z
-    negate_v3_v3(mirrorMat[2], mirrorNormal);
-    copy_v3_v3(mirrorMat[1], mirrorUp);
-    cross_v3_v3v3(mirrorMat[0], mirrorMat[1], mirrorMat[2]);
-    // transpose to make it a orientation matrix from local space to mirror space
-    transpose_m3(mirrorMat);
-    // transform all vertex to plane coordinates and determine mirror position
-    left = FLT_MAX; 
-    right = -FLT_MAX;
-    bottom = FLT_MAX;
-    top = -FLT_MAX;
-    back = -FLT_MAX; // most backward vertex (=highest Z coord in mirror space)
-    for (it = mirrorVerts.begin(); it != mirrorVerts.end(); it++)
-    {   
-        copy_v3_v3(vec, (float*)(*it)->getXYZ());
-        mul_m3_v3(mirrorMat, vec);
-        if (vec[0] < left)
-            left = vec[0];
-        if (vec[0] > right)
-            right = vec[0];
-        if (vec[1] < bottom)
-            bottom = vec[1];
-        if (vec[1] > top)
-            top = vec[1];
-        if (vec[2] > back)
-            back = vec[2];
-    }
-    // now store this information in the object for later rendering
-    m_mirrorHalfWidth = (right-left)*0.5f;
-    m_mirrorHalfHeight = (top-bottom)*0.5f;
-    if (m_mirrorHalfWidth < 0.01f || m_mirrorHalfHeight < 0.01f)
-    {
-        // mirror too small
-        THRWEXCP(MirrorTooSmall, S_OK);
-    }
-    // mirror position in mirror coord
-    vec[0] = (left+right)*0.5f;
-    vec[1] = (top+bottom)*0.5f;
-    vec[2] = back;
-    // convert it in local space: transpose again the matrix to get back to mirror to local transform
-    transpose_m3(mirrorMat);
-    mul_m3_v3(mirrorMat, vec);
-    // mirror position in local space
-    m_mirrorPos.setValue(vec[0], vec[1], vec[2]);
-    // mirror normal vector (pointed towards the back of the mirror) in local space
-    m_mirrorZ.setValue(-mirrorNormal[0], -mirrorNormal[1], -mirrorNormal[2]);
-    m_mirrorY.setValue(mirrorUp[0], mirrorUp[1], mirrorUp[2]);
-    m_mirrorX = m_mirrorY.cross(m_mirrorZ);
-    m_render = true;
+	// mirror position in mirror coord
+	vec[0] = (left+right)*0.5f;
+	vec[1] = (top+bottom)*0.5f;
+	vec[2] = back;
+	// convert it in local space: transpose again the matrix to get back to mirror to local transform
+	transpose_m3(mirrorMat);
+	mul_m3_v3(mirrorMat, vec);
+	// mirror position in local space
+	m_mirrorPos.setValue(vec[0], vec[1], vec[2]);
+	// mirror normal vector (pointed towards the back of the mirror) in local space
+	m_mirrorZ.setValue(-mirrorNormal[0], -mirrorNormal[1], -mirrorNormal[2]);
+	m_mirrorY.setValue(mirrorUp[0], mirrorUp[1], mirrorUp[2]);
+	m_mirrorX = m_mirrorY.cross(m_mirrorZ);
+	m_render = true;
 
 	setBackground(0, 0, 255, 255);
 }
diff --git a/source/gameengine/VideoTexture/ImageViewport.cpp b/source/gameengine/VideoTexture/ImageViewport.cpp
index d0e5ee74f6e..0276ad6fd6b 100644
--- a/source/gameengine/VideoTexture/ImageViewport.cpp
+++ b/source/gameengine/VideoTexture/ImageViewport.cpp
@@ -123,34 +123,34 @@ void ImageViewport::calcImage (unsigned int texId, double ts)
 	}
 	// if texture can be directly created
 	if (texId != 0 && m_pyfilter == NULL && m_capSize[0] == calcSize(m_capSize[0])
-		&& m_capSize[1] == calcSize(m_capSize[1]) && !m_flip)
+	        && m_capSize[1] == calcSize(m_capSize[1]) && !m_flip)
 	{
 		// just copy current viewport to texture
-	    glBindTexture(GL_TEXTURE_2D, texId);
-	    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1]);
-	    // image is not available
-	    m_avail = false;
+		glBindTexture(GL_TEXTURE_2D, texId);
+		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1]);
+		// image is not available
+		m_avail = false;
 	}
 	// otherwise copy viewport to buffer, if image is not available
 	else if (!m_avail)
 	{
 		// get frame buffer data
-        if (m_alpha)
-        {
-    		glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGBA,
-			    GL_UNSIGNED_BYTE, m_viewportImage);
-		    // filter loaded data
-		    FilterRGBA32 filt;
-		    filterImage(filt, m_viewportImage, m_capSize);
-        } 
-        else
-        {
-    		glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGB,
-	    		GL_UNSIGNED_BYTE, m_viewportImage);
-    		// filter loaded data
-		    FilterRGB24 filt;
-		    filterImage(filt, m_viewportImage, m_capSize);
-        }
+		if (m_alpha)
+		{
+			glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGBA,
+			             GL_UNSIGNED_BYTE, m_viewportImage);
+			// filter loaded data
+			FilterRGBA32 filt;
+			filterImage(filt, m_viewportImage, m_capSize);
+		}
+		else
+		{
+			glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGB,
+			             GL_UNSIGNED_BYTE, m_viewportImage);
+			// filter loaded data
+			FilterRGB24 filt;
+			filterImage(filt, m_viewportImage, m_capSize);
+		}
 	}
 }
 
diff --git a/source/gameengine/VideoTexture/VideoFFmpeg.cpp b/source/gameengine/VideoTexture/VideoFFmpeg.cpp
index f8274756c8b..8a76b0c004d 100644
--- a/source/gameengine/VideoTexture/VideoFFmpeg.cpp
+++ b/source/gameengine/VideoTexture/VideoFFmpeg.cpp
@@ -544,11 +544,11 @@ void VideoFFmpeg::openFile (char * filename)
 		// It would be good to find this information from the context but there are no simple indication
 		!strncmp(filename, "http://", 7) ||
 #ifdef FFMPEG_PB_IS_POINTER
-        (m_formatCtx->pb && m_formatCtx->pb->is_streamed)
+		(m_formatCtx->pb && m_formatCtx->pb->is_streamed)
 #else
-        m_formatCtx->pb.is_streamed
+		m_formatCtx->pb.is_streamed
 #endif
-        )
+		)
 	{
 		// the file is in fact a streaming source, treat as cam to prevent seeking
 		m_isFile = false;
diff --git a/source/gameengine/VideoTexture/blendVideoTex.cpp b/source/gameengine/VideoTexture/blendVideoTex.cpp
index c1258bbb6e4..2cb3831de52 100644
--- a/source/gameengine/VideoTexture/blendVideoTex.cpp
+++ b/source/gameengine/VideoTexture/blendVideoTex.cpp
@@ -175,9 +175,9 @@ PyObject* initVideoTexture(void)
 
 	// prepare classes
 	registerAllTypes();
-    registerAllExceptions();
+	registerAllExceptions();
 
-	if (!pyImageTypes.ready()) 
+	if (!pyImageTypes.ready())
 		return NULL;
 	if (!pyFilterTypes.ready()) 
 		return NULL;