Merge remote-tracking branch 'origin/GameClient' into New-inputsystem

Code/Game/GameClient/GameClientState/C_Object.cpp

@@ -5,7 +5,7 @@ C_Object::C_Object()
 	world = Oyster::Math::Float4x4::identity; 
 	position = Oyster::Math::Float3::null; 
 	rotation = Oyster::Math::Quaternion::identity; 
-	scale = Oyster::Math::Float3::null; 
+	scale = Oyster::Math::Float3(1); 
 
 	id = 0;
 	model = NULL;
@@ -88,9 +88,12 @@ int C_Object::GetId() const
 	return id;
 }
 void C_Object::Render()
+{
+	if( this->model )
 	{
 		Oyster::Graphics::API::RenderModel(model);
 	}
+}
 void C_Object::Release()
 {
 	if( this->model )
@@ -100,6 +103,26 @@ void C_Object::Release()
 	}
 }
 
+Oyster::Math::Float3 C_Object::GetTint()
+{
+	return model->Tint;
+}
+
+Oyster::Math::Float3 C_Object::GetGlowTint()
+{
+	return model->GlowTint;
+}
+
+void C_Object::SetTint(Oyster::Math::Float3 tint)
+{
+	model->Tint = tint;
+}
+
+void C_Object::SetGlowTint(Oyster::Math::Float3 tint)
+{
+	model->GlowTint = tint;
+}
+
 
 
 ////////////////////////////////////////////////
@@ -113,14 +136,16 @@ bool C_Object::InitRB(RBInitData RBInit)
 	type = RBInit.type;
 	return true;
 }
-Oyster::Math::Float4x4 C_Object::getRBWorld() const
+void C_Object::updateRBWorld()
 {
 	Oyster::Math3D::Float4x4 translation = Oyster::Math3D::TranslationMatrix(this->RBposition); 
 	Oyster::Math3D::Float4x4 rot = Oyster::Math3D::RotationMatrix(this->RBrotation);
 	Oyster::Math3D::Float4x4 scale = Oyster::Math3D::ScalingMatrix(this->RBscale);
-	Oyster::Math3D::Float4x4 world = translation * rot * scale;
+	RBworld = translation * rot * scale;
-
+}
-	return world;
+Oyster::Math::Float4x4 C_Object::getRBWorld() const
+{
+	return RBworld;
 }
 void C_Object::setRBPos(Oyster::Math::Float3 newPos)
 {

Code/Game/GameClient/GameClientState/C_Object.h

@@ -40,6 +40,7 @@ namespace DanBias
 			Oyster::Math::Float3 scale; 
 
 			// RB DEBUG
+			Oyster::Math::Float4x4 RBworld; 
 			Oyster::Math::Float3 RBposition; 
 			Oyster::Math::Quaternion RBrotation; 
 			Oyster::Math::Float3 RBscale; 
@@ -66,7 +67,15 @@ namespace DanBias
 			void addScale(Oyster::Math::Float3 deltaScale);
 			Oyster::Math::Float3  getScale() const;
 
+			Oyster::Math::Float3 GetTint();
+			Oyster::Math::Float3 GetGlowTint();
+
+			void SetTint(Oyster::Math::Float3);
+			void SetGlowTint(Oyster::Math::Float3);
+
+
 			// RB DEBUG
+			void updateRBWorld();
 			bool InitRB(RBInitData modelInit);
 			Oyster::Math::Float4x4 getRBWorld() const;
 			void setRBPos(Oyster::Math::Float3 newPos);

Code/Game/GameClient/GameClientState/GameState.cpp

@@ -126,6 +126,7 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 	RBData.position = position;
 	RBData.rotation = ArrayToQuaternion( rotation );
 	RBData.scale =  scale;
+	RBData.type = RB_Type_Cube;
 	// !RB DEBUG 
 	if( isMyPlayer )
 	{
@@ -138,7 +139,10 @@ void GameState::InitiatePlayer( int id, const std::string &modelName, const floa
 			this->privData->myId = id;
 			this->privData->camera.SetPosition( this->privData->player.getPos() );
 			Float3 offset = Float3( 0.0f );
-			offset.y = this->privData->player.getScale().y * 0.9f;
+			// DEBUG position of camera so we can see the player model
+			offset.y = this->privData->player.getScale().y * 5.0f;
+			offset.z = this->privData->player.getScale().z * -5.0f;
+			// !DEBUG
 			this->privData->camera.SetHeadOffset( offset );
 			this->privData->camera.UpdateOrientation();
 		}
@@ -182,8 +186,10 @@ bool GameState::Render()
 	for( ; dynamicObject != this->privData->dynamicObjects->end(); ++dynamicObject )
 	{
 		if( dynamicObject->second )
+		{
 			dynamicObject->second->Render();
 		}
+	}
 
 
 	/*auto light = this->privData->lights->begin();
@@ -327,7 +333,11 @@ void GameState::ReadKeyInput()
 	{
 		static const float mouseSensitivity = Radian( 1.0f );
 		this->privData->camera.PitchDown( this->privData->input->GetPitch() * mouseSensitivity );
-		this->privData->nwClient->Send( Protocol_PlayerLeftTurn(this->privData->input->GetYaw() * mouseSensitivity) );
+		float yaw = this->privData->input->GetYaw();
+		//if( yaw != 0.0f )	//This made the camera reset to a specific rotation.
+		{
+			this->privData->nwClient->Send( Protocol_PlayerLeftTurn(yaw * mouseSensitivity) );
+		}
 	}
 
 	// shoot
@@ -496,6 +506,12 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 					this->privData->camera.SetRotation( rotation );
 					this->privData->player.setPos( position );
 					this->privData->player.setRot( rotation );
+					this->privData->player.updateWorld();
+					// RB DEBUG 
+					this->privData->player.setRBPos ( position );  
+					this->privData->player.setRBRot ( rotation );  
+					this->privData->player.updateRBWorld();
+					// !RB DEBUG 
 				}
 
 				C_DynamicObj *object = (*this->privData->dynamicObjects)[decoded.object_ID];
@@ -504,9 +520,11 @@ const GameClientState::NetEvent & GameState::DataRecieved( const GameClientState
 				{
 					object->setPos( position );
 					object->setRot( rotation );
+					object->updateWorld();
 					// RB DEBUG 
 					object->setRBPos ( position );  
 					object->setRBRot ( rotation );  
+					object->updateRBWorld();
 					// !RB DEBUG 
 				}
 			}

Code/Game/GameClient/GameClientState/NetLoadState.cpp

@@ -157,6 +157,7 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 						RBData.scale =  (Float3)oh->scale * (Float3)oh->boundingVolume.box.size * 2;
 						RBData.type = RB_Type_Cube;
 						staticObject->InitRB( RBData );
+						staticObject->updateRBWorld();
 					}
 
 					if(oh->boundingVolume.geoType == CollisionGeometryType_Sphere)
@@ -166,6 +167,7 @@ void NetLoadState::LoadGame( const ::std::string &fileName )
 						RBData.scale =  (Float3)oh->scale * oh->boundingVolume.sphere.radius * 2;
 						RBData.type = RB_Type_Sphere;
 						staticObject->InitRB( RBData );
+						staticObject->updateRBWorld();
 					}
 					// !RB DEBUG 
 

Code/Game/GameLogic/CollisionManager.cpp

@@ -22,10 +22,14 @@ using namespace GameLogic;
 	//Physics::ICustomBody::SubscriptMessage
 	void Player::PlayerCollision(Oyster::Physics::ICustomBody *rigidBodyPlayer, Oyster::Physics::ICustomBody *obj, Oyster::Math::Float kineticEnergyLoss)
 	{
-		
 		Player *player = ((Player*)(rigidBodyPlayer->GetCustomTag()));
 		Object *realObj = (Object*)obj->GetCustomTag(); //needs to be changed?
 
+		if(!realObj)	
+			return;
+		if(!player)		
+			return;
+
 		switch (realObj->GetObjectType())
 		{
 		case ObjectSpecialType::ObjectSpecialType_Generic:

Code/Game/GameLogic/Game_PlayerData.cpp

@@ -5,7 +5,7 @@ using namespace GameLogic;
 
 Game::PlayerData::PlayerData()
 {	
-	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,250,0);
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,180,0);
 	Oyster::Math::Float height = 2.0f;
 	Oyster::Math::Float radius = 0.5f;
 	Oyster::Math::Float mass = 40;
@@ -24,7 +24,7 @@ Game::PlayerData::PlayerData()
 Game::PlayerData::PlayerData(int playerID,int teamID)
 {
 
-	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,250,0);
+	Oyster::Math::Float3 centerPosition = Oyster::Math::Float3(-50,180,0);
 	Oyster::Math::Float height = 2.0f;
 	Oyster::Math::Float radius = 0.5f;
 	Oyster::Math::Float mass = 40;

Code/Game/GameLogic/Level.cpp

@@ -300,6 +300,7 @@ bool Level::InitiateLevel(std::wstring levelPath)
 					Object* dynamicGameObj = CreateGameObj(dynamicObjData, rigidBody_Dynamic);
 					if (dynamicGameObj != NULL)
 					{
+						dynamicGameObj->GetRigidBody()->SetSubscription(Level::PhysicsOnMoveLevel);
 						this->dynamicObjects.Push((DynamicObject*)dynamicGameObj);
 					}
 				}

Code/Game/GameLogic/Object.cpp

@@ -30,6 +30,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody, void (*collisionFuncAfte
 	this->objectID = objectID;
 	this->extraDamageOnCollision = 0;
 	this->rigidBody->SetCustomTag(this);
+	this->scale = Float3(1.0f, 1.0f, 1.0f);
 }
 
 
@@ -41,6 +42,7 @@ Object::Object(Oyster::Physics::ICustomBody *rigidBody , Oyster::Physics::ICusto
 	this->objectID = objectID;
 	this->extraDamageOnCollision = 0;
 	this->rigidBody->SetCustomTag(this);
+	this->scale = Float3(1.0f, 1.0f, 1.0f);
 }
 
 Object::~Object(void)

Code/Game/GameLogic/Player.cpp

@@ -127,7 +127,7 @@ void Player::BeginFrame()
 	}
 	
 
-	if (key_forward <= 0.001 && key_backward <= 0.001 && key_strafeRight <= 0.001 && key_strafeLeft <= 0.001 && key_jump <= 0.001 ) //&& this->rigidBody->GetLambda() < 0.7f)
+	if (key_forward <= 0.001 && key_backward <= 0.001 && key_strafeRight <= 0.001 && key_strafeLeft <= 0.001 && key_jump <= 0.001 && this->rigidBody->GetLambda() < 0.7f)
 	{
 		/* Dampen when on the ground and not being moved by the player */
 		linearVelocity *= 0.2f;

Code/Game/GameProtocols/PlayerProtocols.h

@@ -97,6 +97,8 @@ namespace GameLogic
 		{
 			this->protocol[0].value = protocol_Gameplay_PlayerLeftTurn;
 			this->protocol[0].type = ::Oyster::Network::NetAttributeType_Short;
+			// deltaRadian
+			this->protocol[1].type = ::Oyster::Network::NetAttributeType_Float;
 			this->deltaRadian = deltaRadian;
 		}
 		

Code/Game/GameServer/Implementation/GameSession_Gameplay.cpp

@@ -61,18 +61,16 @@ using namespace DanBias;
 		switch (e.args.type)
 		{
 			case NetworkClient::ClientEventArgs::EventType_Disconnect:
-				//printf("\t(%i : %s) - EventType_Disconnect\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
+				printf("\t(%i : %s) - EventType_Disconnect\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
 				this->gClients[temp]->Invalidate();
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToRecieve:
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolFailedToSend:
-				//printf("\t(%i : %s) - EventType_ProtocolFailedToSend\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
 				if(this->gClients[temp]->IncrementFailedProtocol() >= 5/*client->threshold*/)
 					this->gClients[temp]->Invalidate();
 			break;
 			case NetworkClient::ClientEventArgs::EventType_ProtocolRecieved:
-				//printf("\t(%i : %s) - EventType_ProtocolRecieved\n", cl->GetClient()->GetID(), e.sender->GetIpAddress().c_str());	
 				this->ParseProtocol(e.args.data.protocol, cl);
 			break;
 		}

Code/Game/LanServer/GameServerDebugEnvironment/Source.cpp

@@ -10,6 +10,8 @@
 
 using namespace DanBias;
 
+
+
 int WINAPI WinMain( HINSTANCE hinst, HINSTANCE prevInst, PSTR cmdLine, int cmdShow)
 {
 	if(SetDllDirectory(L"..\\DLL") == FALSE)

Code/Misc/Input/L_inputClass.cpp

@@ -189,7 +189,7 @@ float InputClass::GetPitch( )
 float InputClass::GetYaw( )
 {
 	float dX = (static_cast<float>( m_mouseState.lX)/5);
-	return -dX;
+	return dX;
 }
 
 bool InputClass::IsMousePressed()

Code/Network/NetworkAPI/NetworkClient.cpp

@@ -64,7 +64,7 @@ struct NetworkClient::PrivateData : public IThreadObject
 		:	ID(currID++)
 		,	parent(0)
 		,	owner(0)
-		,	outputEvent(1)
+		,	outputEvent(0)
 	{ 
 		InitWinSock();
 		this->thread.Create(this, false);

Code/Network/NetworkDependencies/ConnectionUDP.cpp

@@ -0,0 +1,218 @@
+#include "ConnectionUDP.h"
+
+#include <WinSock2.h>
+
+using namespace Oyster::Network;
+
+ConnectionUDP::ConnectionUDP()
+{
+	this->ipSize = 16;
+	this->socket = -1;
+	this->stillSending = false;
+	this->closed = true;
+	this->Address = NULL;
+}
+
+ConnectionUDP::ConnectionUDP( int socket )
+{
+	this->ipSize = 16;
+	this->socket = socket;
+	this->stillSending = false;
+	this->closed = true;
+	this->Address = NULL;
+}
+
+ConnectionUDP::~ConnectionUDP()
+{
+	closesocket( this->socket );
+}
+
+int ConnectionUDP::Connect(unsigned short port, const char serverName[])
+{
+	this->port = port;
+	
+	closed = false;
+	stillSending = true;
+
+	struct hostent *hostEnt;
+	if((hostEnt = gethostbyname(serverName)) == NULL)
+	{
+		return SOCKET_ERROR;
+	}
+
+	
+	this->Address = *(unsigned long*)hostEnt->h_addr;
+	this->port = htons(this->port);
+	return 0;
+}
+
+int ConnectionUDP::Disconnect()
+{
+	int result = closesocket(this->socket);
+
+	if(result == SOCKET_ERROR)
+	{
+		return result;
+	}
+
+	return 0;
+}
+
+int ConnectionUDP::InitiateServer(unsigned short port)
+{
+	int errorCode = 0;
+
+	if((errorCode = InitiateSocket()) != 0)
+	{
+		return errorCode;
+	}
+
+	struct sockaddr_in server;
+	server.sin_family = AF_INET;
+	server.sin_addr.s_addr = INADDR_ANY;
+	server.sin_port = htons(port);
+
+	if(bind(this->socket, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
+	{
+		errorCode = SOCKET_ERROR;
+		closesocket(this->socket);
+		return errorCode;
+	}
+
+	closed = false;
+	stillSending = true;
+	return 0;
+}
+
+int ConnectionUDP::InitiateClient()
+{
+	return InitiateSocket();
+}
+
+int ConnectionUDP::InitiateBroadcast(unsigned short port)
+{
+	int result = InitiateSocket();
+
+
+	int flag = 1;
+	result = setsockopt(this->socket,			/* socket affected */
+							SOL_SOCKET,			/* set option at TCP level */
+							SO_BROADCAST,		/* name of option */
+							(char *) &flag,		/* the cast is historical cruft */
+							sizeof(flag));		/* length of option value */
+	if (result < 0)
+		return -1;
+}
+
+int ConnectionUDP::Send(OysterByte &bytes)
+{
+	int nBytes;
+	struct sockaddr_in reciever;
+	reciever.sin_family = AF_INET;
+	reciever.sin_addr.s_addr = this->Address;
+	reciever.sin_port = port;
+
+	//printf("Send: %d\n", bytes.GetSize());
+	nBytes = sendto(this->socket,
+					bytes,
+					bytes.GetSize(),
+					0,
+					(sockaddr*)&reciever, 
+					sizeof(sockaddr_in)
+					); 
+
+	if ( nBytes != bytes.GetSize() )
+    {
+		return nBytes;
+    }
+
+	return 0;
+}
+
+int ConnectionUDP::Recieve(OysterByte &bytes)
+{
+	int nBytes;
+	sockaddr_in from;
+    int fromLength = sizeof( from );
+
+	bytes.Resize(1000);
+	nBytes = recvfrom(this->socket,
+					  bytes,
+					  1000,
+					  0,
+					  (sockaddr*)&from,
+					  &fromLength 
+					  );
+
+
+	if(nBytes <= 0)
+	{
+		bytes.SetSize(0);
+		return WSAGetLastError();
+	}
+	else
+	{
+		bytes.SetSize(nBytes);
+	}
+
+
+	//address and port of the client who sent the message
+	unsigned int from_address = ntohl( from.sin_addr.s_addr );
+    unsigned int from_port = ntohs( from.sin_port );
+
+
+	return 0;
+}
+
+bool ConnectionUDP::IsSending()
+{
+	return stillSending;
+}
+
+bool ConnectionUDP::IsConnected()
+{
+	if(closed)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+int ConnectionUDP::SetBlockingMode( bool blocking )
+{
+	DWORD nonBlocking;
+
+	if(blocking)
+	{
+		nonBlocking = 0;
+	}
+	else
+	{
+		nonBlocking = 1;
+	}
+
+	int result = ioctlsocket(this->socket, FIONBIO, &nonBlocking);
+	if(result != 0)
+	{
+		return result;
+	}
+
+	//Success
+	return 0;
+}
+//////////////////////////////////////
+// Private Methods
+//////////////////////////////////////
+
+int ConnectionUDP::InitiateSocket()
+{
+	this->socket = (int)::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+
+	if(this->socket == SOCKET_ERROR)
+	{
+		return socket;
+	}
+
+	return 0;
+}

Code/Network/NetworkDependencies/ConnectionUDP.h

@@ -0,0 +1,57 @@
+#ifndef NETWORK_DEPENDENCIES_CONNECTIONUDP_H
+#define NETWORK_DEPENDENCIES_CONNECTIONUDP_H
+
+//////////////////////////////////
+// Created by Sam Svensson 2013 //
+//////////////////////////////////
+
+#include "IConnection.h"
+#include "../NetworkDependencies/OysterByte.h"
+
+namespace Oyster
+{
+	namespace Network
+	{
+		class ConnectionUDP : public IConnection
+		{
+		public:
+			ConnectionUDP();
+			ConnectionUDP( int socket);
+			virtual ~ConnectionUDP();
+
+			virtual int InitiateServer( unsigned short port );
+			virtual int InitiateClient();
+
+			virtual int InitiateBroadcast(unsigned short port);
+
+			virtual int Send ( OysterByte &byte );
+			virtual int Recieve( OysterByte &byte );
+
+			virtual int Connect( unsigned short port, const char serverName[] );
+
+			virtual int Disconnect();
+
+			bool IsSending();
+			bool IsConnected();
+			int GetIpSize();
+
+			int SetBlockingMode( bool blocking );
+
+		private:
+			int InitiateSocket();
+
+			int socket;
+			//char ipAddress[16];
+			//unsigned short port;
+			int ipSize;
+			
+			unsigned long Address;
+			unsigned short port;
+
+			bool stillSending;
+			bool closed;
+		};
+	}
+}
+
+#endif

Code/Network/NetworkDependencies/NetworkDependencies.vcxproj

@@ -147,6 +147,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="Connection.cpp" />
+    <ClCompile Include="ConnectionUDP.cpp" />
     <ClCompile Include="Listener.cpp" />
     <ClCompile Include="Messages\MessageHeader.cpp" />
     <ClCompile Include="Messages\MessagePlayerPos.cpp" />
@@ -157,6 +158,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Connection.h" />
+    <ClInclude Include="ConnectionUDP.h" />
     <ClInclude Include="IConnection.h" />
     <ClInclude Include="IPostBox.h" />
     <ClInclude Include="Listener.h" />

Code/Network/NetworkDependencies/NetworkDependencies.vcxproj.filters

@@ -9,6 +9,7 @@
     <ClCompile Include="OysterByte.cpp" />
     <ClCompile Include="ThreadedClient.cpp" />
     <ClCompile Include="WinsockFunctions.cpp" />
+    <ClCompile Include="ConnectionUDP.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Connection.h" />
@@ -25,5 +26,6 @@
     <ClInclude Include="Protocols.h" />
     <ClInclude Include="ThreadedClient.h" />
     <ClInclude Include="WinsockFunctions.h" />
+    <ClInclude Include="ConnectionUDP.h" />
   </ItemGroup>
 </Project>

Code/OysterGraphics/Definitions/GraphicalDefinition.h

@@ -79,6 +79,14 @@ namespace Oyster
 				unsigned int StopY;
 				Math::Float4 BlurMask;
 			};
+
+			struct TintData
+			{
+				Math::Float3 Tint;
+				Math::Float PAD;
+				Math::Float3 GlowTint;
+				Math::Float PAD2;
+			};
 		}
 	}
 }

Code/OysterGraphics/DllInterfaces/GFXAPI.cpp

@@ -139,6 +139,7 @@ namespace Oyster
 			m->Visible = true;
 			m->Animation.AnimationPlaying = NULL;
 			m->Tint = Math::Float3(1);
+			m->GlowTint = Math::Float3(1);
 			m->info = (Model::ModelInfo*)Core::loader.LoadResource((Core::modelPath + filename).c_str(),Oyster::Graphics::Loading::LoadDAN, Oyster::Graphics::Loading::UnloadDAN);
 
 			Model::ModelInfo* mi = (Model::ModelInfo*)m->info;

Code/OysterGraphics/Model/Model.h

@@ -24,6 +24,7 @@ namespace Oyster
 				ModelInfo* info;
 				Oyster::Math::Float4x4 WorldMatrix;
 				Oyster::Math::Float3 Tint;
+				Oyster::Math::Float3 GlowTint;
 				bool Visible;
 				AnimationData Animation;
 			};

Code/OysterGraphics/Render/DefaultRenderer.cpp

@@ -136,8 +136,15 @@ namespace Oyster
 							memcpy(data,&(pm),sizeof(pm));
 							Resources::Gather::ModelData.Unmap();
 
+							Definitions::TintData td;
+							td.GlowTint = models[i].GlowTint;
+							td.Tint = models[i].Tint;
+							td.PAD = 0;
+							td.PAD2 = 0;
+							int s = sizeof(Definitions::TintData);
+
 							data = Render::Resources::Color.Map();
-							memcpy(data,&models[i].Tint,sizeof(Math::Float3));
+							memcpy(data,&td,sizeof(Definitions::TintData));
 							Render::Resources::Color.Unmap(); 
 
 							if(info->Material.size())

Code/OysterGraphics/Render/Resources.cpp

@@ -123,7 +123,7 @@ namespace Oyster
 					Gather::AnimationData.Init(desc);
 
 					desc.Type = Buffer::BUFFER_TYPE::CONSTANT_BUFFER_PS;
-					desc.ElementSize = sizeof(Math::Float3);
+					desc.ElementSize = sizeof(Definitions::TintData);
 					Color.Init(desc);
 
 					desc.Type = Buffer::BUFFER_TYPE::CONSTANT_BUFFER_GS;
@@ -176,7 +176,7 @@ namespace Oyster
 					sdesc.Filter = D3D11_FILTER_ANISOTROPIC;
 					sdesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
 					sdesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
-					sdesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+					sdesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
 					sdesc.MipLODBias = 0;
 					sdesc.MaxAnisotropy =4;
 					sdesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;

Code/OysterGraphics/Shader/Passes/Gather/GatherPixel.hlsl

@@ -40,7 +40,10 @@ float3 perturb_normal( float3 N, float3 V, float2 texcoord )
 PixelOut main(VertexOut input)
 {
 	PixelOut output;
-	output.DiffuseGlow = Diffuse.Sample(S1, input.UV) * float4(Color, 1);
+	float4 DiffGlow = Diffuse.Sample(S1, input.UV);
+	float3 tint = Color*(1-DiffGlow) + GlowColor * DiffGlow;
+	tint = tint / 2;
+	output.DiffuseGlow = DiffGlow * float4(tint,1);
 
 	//NORMALIZE
 	float3x3 CoTangentFrame = cotangent_frame(input.normal, normalize(input.ViewPos), input.UV);

Code/OysterGraphics/Shader/Passes/Gather/Header.hlsli

@@ -42,4 +42,7 @@ cbuffer PerModel : register(b1)
 cbuffer Tint : register(b0)
 {
 	float3 Color;
+	float PAD;
+	float3 GlowColor;
+	float PAD2;
 }

Code/Physics/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -283,6 +283,11 @@ void API_Impl::UpdateWorld()
 		SimpleRigidBody* simpleBody = dynamic_cast<SimpleRigidBody*>(this->customBodies[i]);
 		this->customBodies[i]->SetGravity(-(this->customBodies[i]->GetState().centerPos - this->gravityPoint).GetNormalized()*this->gravity);
 		simpleBody->PreStep(this->dynamicsWorld);
+
+		if(simpleBody->GetRigidBody()->getActivationState() == ACTIVE_TAG)
+		{
+			this->customBodies[i]->CallSubscription_Move();
+		}	
 	}
 
 	this->dynamicsWorld->stepSimulation(this->timeStep, 1, this->timeStep);
@@ -296,11 +301,6 @@ void API_Impl::UpdateWorld()
 		trans = simpleBody->GetRigidBody()->getWorldTransform();
 		this->customBodies[i]->SetPosition(Float3(trans.getOrigin().x(), trans.getOrigin().y(), trans.getOrigin().z()));
 		this->customBodies[i]->SetRotation(Quaternion(Float3(trans.getRotation().x(), trans.getRotation().y(), trans.getRotation().z()), trans.getRotation().w()));		
-
-		if(simpleBody->GetRigidBody()->getActivationState() == ACTIVE_TAG)
-		{
-			this->customBodies[i]->CallSubscription_Move();
-		}		
 	}
 
 	int numManifolds = this->dynamicsWorld->getDispatcher()->getNumManifolds();