public virtual int DeInitializeComponent(int entityID, ECSComponent component)
{
if (component.GetType() == typeof(CTransform))
{
CTransform cTransform = component as CTransform;
GameObject.Destroy(cTransform.GameObject);
}
if (component.GetType() == typeof(CSpriteRenderer))
{
CSpriteRenderer cRenderer = component as CSpriteRenderer;
DestroyUnityComponent <SpriteRenderer>(entityID, cRenderer);
}
if (component.GetType() == typeof(CBoxCollider))
{
CBoxCollider cBoxCollider = component as CBoxCollider;
OnColliderRemoved(entityID, cBoxCollider.BoxCollider);
DestroyUnityComponent <BoxCollider>(entityID, cBoxCollider);
}
if (component.GetType() == typeof(CMeshCollider))
{
CMeshCollider cMeshCollider = component as CMeshCollider;
OnColliderRemoved(entityID, cMeshCollider.Collider);
DestroyUnityComponent <MeshCollider>(entityID, cMeshCollider);
}
if (component.GetType() == typeof(CSphereCollider))
{
CSphereCollider cSphereCollider = component as CSphereCollider;
OnColliderRemoved(entityID, cSphereCollider.Collider);
DestroyUnityComponent <SphereCollider>(entityID, cSphereCollider);
}
if (component.GetType() == typeof(CRigidbody))
{
CRigidbody cRigidbody = component as CRigidbody;
DestroyUnityComponent <Rigidbody>(entityID, cRigidbody);
}
if (component.GetType() == typeof(CMeshRenderer))
{
CMeshRenderer cMeshRenderer = component as CMeshRenderer;
DestroyUnityComponent <MeshRenderer>(entityID, cMeshRenderer);
DestroyUnityComponent <MeshFilter>(entityID, cMeshRenderer);
}
return(0);
}
public void MultiQubitApplicationTest()
{
Qubit control = new Qubit(ComplexExt.OneOverRootTwo, ComplexExt.OneOverRootTwo);
Qubit target = new Qubit(1, 0);
IQuantumState bell = new CTransform(Gates.Not).Transform(new MultiQubit(control, target));
IQuantumState res = new PartialTransform(4, Gates.H, new[] { 0 }).Transform(bell);
res.GetAmplitude("00".ToBits()).ShouldBe(new Complex(1.0 / 2, 0));
res.GetAmplitude("11".ToBits()).ShouldBe(-new Complex(1.0 / 2, 0));
res.GetAmplitude("01".ToBits()).ShouldBe(new Complex(1.0 / 2, 0));
res.GetAmplitude("10".ToBits()).ShouldBe(new Complex(1.0 / 2, 0));
}
//--------------------------------------
// NON-PUBLIC METHODS
//--------------------------------------
/// <summary>Creates a new ball in the scene with the given position and velocity.</summary>
/// <param name="p">The ball position, in world-space.</param>
/// <param name="v">The initial velocity to give to the ball.</param>
/// <param name="r">The ball radius.</param>
/// <param name="reflective">Whether to use an environment mapped material.</param>
private int CreateBall(Vector3 p, Vector3 v, float r = 1.0f, bool reflective = false)
{
var ball = AddEntity();
AddComponent(ball, new CBody {
Aabb = new BoundingBox(-r * Vector3.One, r * Vector3.One),
Radius = r,
LinDrag = 0.1f,
Velocity = v
});
CTransform transf;
AddComponent(ball, transf = new CTransform {
Position = p,
Rotation = Matrix.Identity,
Scale = r * Vector3.One
});
EnvMapMaterial envMap = null;
if (reflective)
{
var rot = 0.0f;
envMap = new EnvMapMaterial(mRenderer,
ball,
(CTransform)GetComponentFromEntity <CTransform>(ball),
Game1.Inst.Content.Load <Texture2D>("Textures/Bumpmap0"));
// TODO: If the camera moves, this needs to be done every frame.
//envMap.SetCameraPos(new Vector3(9.0f, 12.0f, 18.0f));
AddComponent(ball, new CLogic {
Fn = (t, dt) => {
rot += 1.0f * dt;
transf.Rotation = Matrix.CreateRotationX(rot)
* Matrix.CreateRotationY(0.7f * rot);
envMap.Update();
},
InvHz = 1.0f / 30.0f
});
}
AddComponent <C3DRenderable>(ball, new CImportedModel {
materials = new Dictionary <int, MaterialShader> {
{ 0, reflective ? envMap : null }
},
model = Game1.Inst.Content.Load <Model>("Models/DummySphere")
});
return(ball);
}
public override void Update(float t, float dt)
{
foreach (var camera in Game1.Inst.Scene.GetComponents <CCamera>())
{
CCamera cameraComponent = (CCamera)camera.Value;
CTransform transformComponent = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(camera.Key);
Vector3 cameraPosition = transformComponent.Position;
cameraComponent.View = Matrix.CreateLookAt(cameraPosition, cameraComponent.Target, Vector3.Up);
}
base.Update(t, dt);
}
public void OnStart()
{
//base.OnStart();
currAliveTimer = MMath.GetRandomLimitedFloat(_monsterMinActiveTime, _monsterMaxActiveTime);
currDeadTimer = MMath.GetRandomLimitedFloat(_monsterMinRestTime, _monsterMaxRestTime);
chilloutFace = GameObject.GetGameObjectByName("maxChill");
faceRender = chilloutFace.RequireComponent <CSkinMeshRenderer>();
faceTransform = chilloutFace.RequireComponent <CTransform>();
faceRender.setEnabled(false);
distortScript = GetScript <DistortForTime>(gameObject);
}
private void ComponentPreProcessing(string archetype, Bag <ECSComponent> components)
{
foreach (ECSComponent component in components)
{
if (component.GetType() == typeof(CTransform))
{
CTransform cTransform = (component as CTransform);
if (cTransform.Name == null)
{
cTransform.Name = archetype;
}
}
}
}
public override void Handle(float t, float dt)
{
var npcTransform = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(entityId);
var npcBody = (CBody)Game1.Inst.Scene.GetComponentFromEntity <CBody>(entityId);
var aiComponent = (CAI)Game1.Inst.Scene.GetComponentFromEntity <CAI>(entityId);
var flock = (CFlock)Game1.Inst.Scene.GetComponentFromEntity <CFlock>(aiComponent.Flock);
var rotationSpeed = Math.Min(1.8f * dt, 1);
var movementSpeed = dt * flock.PreferredMovementSpeed * 5;
var closestEnemyDistance = float.MaxValue;
var closestEnemyId = -1;
CTransform closestEnemyTransform = null;
foreach (var player in Game1.Inst.Scene.GetComponents <CInput>())
{
if (!Game1.Inst.Scene.EntityHasComponent <CBody>(player.Key))
{
continue;
}
var playerTransform = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(player.Key);
var positionDiff = playerTransform.Position - npcTransform.Position;
float distance = (float)Math.Sqrt(Math.Pow(positionDiff.X, 2) + 0 + Math.Pow(positionDiff.Z, 2));
if (closestEnemyDistance > distance)
{
closestEnemyDistance = distance;
closestEnemyId = player.Key;
closestEnemyTransform = playerTransform;
}
}
if (closestEnemyId == -1)
{
return;
}
Vector3 dest = Vector3.Normalize(closestEnemyTransform.Position - npcTransform.Position);
var source = Vector3.Backward;
var goalQuat = PositionalUtil.GetRotation(source, dest, Vector3.Up);
var startQuat = npcTransform.Rotation.Rotation;
var dQuat = Quaternion.Lerp(startQuat, goalQuat, rotationSpeed);
dQuat.X = 0;
dQuat.Z = 0;
npcTransform.Rotation = Matrix.CreateFromQuaternion(dQuat);
// move forward in set direction
npcBody.Velocity.X = (movementSpeed * npcTransform.Rotation.Forward).X;
npcBody.Velocity.Z = (movementSpeed * npcTransform.Rotation.Forward).Z;
}
// Note: X is correct axis, but Y in this case actually is Z in game world (Y is for height)
public float HeightPosition(float x, float y)
{
foreach (var renderable in Game1.Inst.Scene.GetComponents <C3DRenderable>())
{
if (renderable.Value.GetType() != typeof(CHeightmap))
{
continue;
}
var heightmap = (CHeightmap)renderable.Value;
var key = renderable.Key;
CTransform transform = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(key);
x -= transform.Position.X;
y -= transform.Position.Z;
if (x < 0 || x > heightmap.Image.Width || y < 0 || y > heightmap.Image.Height)
{
return(0);
}
// get four closest vertices
int lowX = (int)Math.Floor(x);
int highX = (int)Math.Floor(x + 1);
int lowY = (int)Math.Floor(y);
int highY = (int)Math.Floor(y + 1);
var A = mHeightData[lowX, lowY];
var B = mHeightData[highX, lowY];
var C = mHeightData[lowX, highY];
var D = mHeightData[highX, highY];
// lerp func
Func <float, float, float, float> f = (a, b, sigma) => (1.0f - sigma) * a + sigma * b;
// fractional parts
var fX = x - lowX;
var fY = y - lowY;
// 2d-interpolate over the square
var h = f(f(A, B, fX), f(C, D, fX), fY);
// P = (x, y)
// f(a,b,x) = xa + (1-x)b
// Pz = f(f(A,B,Px), f(C, D, Px), Py
return(h * transform.Scale.Y);
}
return(0);
}
//--------------------------------------
// NON-PUBLIC METHODS
//--------------------------------------
/// <summary>Creates a new ball in the scene with the given position and velocity.</summary>
/// <param name="p">The ball position, in world-space.</param>
/// <param name="v">The initial velocity to give to the ball.</param>
/// <param name="r">The ball radius.</param>
/// <param name="reflective">Whether to use an environment mapped material.</param>
private int CreateBall(Vector3 p, Vector3 v, float r = 1.0f, bool reflective = false)
{
var ball = AddEntity();
AddComponent(ball, new CBody {
Aabb = new BoundingBox(-r * Vector3.One, r * Vector3.One),
Radius = r,
LinDrag = 0.1f,
Position = p,
Velocity = v
});
CTransform transf;
AddComponent(ball, transf = new CTransform {
Position = p,
Rotation = Matrix.Identity,
Scale = r * Vector3.One
});
if (reflective)
{
var rot = 0.0f;
AddComponent(ball, new CInput());
envMap = new EnvMapMaterial(mRenderer,
ball,
(CTransform)GetComponentFromEntity <CTransform>(ball),
mSkybox);
AddComponent(ball, new CLogic {
Fn = (t, dt) => {
rot += 1.0f * dt;
transf.Rotation = Matrix.CreateRotationX(rot)
* Matrix.CreateRotationY(0.7f * rot);
envMap.Update();
},
InvHz = 1.0f / 30.0f
});
}
AddComponent <C3DRenderable>(ball, new CImportedModel {
material = reflective ? envMap : null,
model = Game1.Inst.Content.Load <Model>("Models/DummySphere")
});
return(ball);
}
private CTransform VerifyTransform(ECSComponent component, int entityID)
{
CTransform cTransform = GetComponent <CTransform>(component, entityID);
if (cTransform == null)
{
return(null);
}
if (cTransform.GameObject == null)
{
OnComponentInitializeFailure(component, "GameObject does not exist!");
return(null);
}
return(cTransform);
}
public void OnStart()
{
trans_ = gameObject.RequireComponent <CTransform>();
item_ = 0;
itemPos_ = new List <Vector2>();
// Quit
itemPos_.Insert(0, new Vector2(0.047f, -0.075f));
// Credits
itemPos_.Insert(0, new Vector2(0.04f, -0.048f));
// Options
itemPos_.Insert(0, new Vector2(0.04f, -0.025f));
// How To Play
itemPos_.Insert(0, new Vector2(0.057f, 0.0f));
// Start
itemPos_.Insert(0, new Vector2(0.03f, 0.025f));
}
public void OnStart()
{
trans_ = gameObject.RequireComponent <CTransform>();
item_ = 0;
itemPos_ = new List <Vector2>();
// Quit
itemPos_.Insert(0, new Vector2(0.14f, -0.045f));
// Main Menu
itemPos_.Insert(0, new Vector2(0.14f, -0.012f));
// Options
itemPos_.Insert(0, new Vector2(0.14f, 0.022f));
// How To Play
itemPos_.Insert(0, new Vector2(0.14f, 0.032f));
// Resume
itemPos_.Insert(0, new Vector2(0.16f, 0.042f));
}
private void CalculateHeightData(CHeightmap compHeight, int key)
{
CTransform transformComponent = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(key);
int terrainWidth = compHeight.Image.Width;
int terrainHeight = compHeight.Image.Height;
var colorMap = new Color[terrainWidth * terrainHeight];
compHeight.Image.GetData(colorMap);
compHeight.HeightData = new Color[terrainWidth, terrainHeight];
mHeightData = new float[terrainWidth, terrainHeight];
for (int x = 0; x < terrainWidth; x++)
{
for (int y = 0; y < terrainHeight; y++)
{
compHeight.HeightData[x, y] = colorMap[x + y * terrainWidth];
mHeightData[x, y] = colorMap[x + y * terrainWidth].R + transformComponent.Position.Y;
if (compHeight.elements.ContainsKey(colorMap[x + y * terrainWidth].B))
{
var s = 0.05f;
compHeight.EnvironmentSpawn.Add(new Vector4(s * x, mHeightData[x, y], s * y, colorMap[x + y * terrainWidth].B));
}
}
}
float minHeight = float.MaxValue;
float maxHeight = float.MinValue;
for (int x = 0; x < terrainWidth; x++)
{
for (int y = 0; y < terrainHeight; y++)
{
if (compHeight.HeightData[x, y].R < minHeight)
{
compHeight.LowestPoint = compHeight.HeightData[x, y].R;
}
if (compHeight.HeightData[x, y].R > maxHeight)
{
compHeight.HeighestPoint = compHeight.HeightData[x, y].R;
}
}
}
}
private void SetupBasicEffect(BasicEffect effect,
CCamera camera,
C3DRenderable model,
Scene scene,
CTransform transform,
ModelMesh mesh,
Matrix anim,
Matrix boneTransform,
LightingConfig config)
{
// TODO: we want the same lighting everywhere so no cheating with this ;) (other shaders dont have this)
effect.EnableDefaultLighting();
effect.PreferPerPixelLighting = true;
effect.VertexColorEnabled = model.enableVertexColor;
effect.LightingEnabled = true;
effect.AmbientLightColor = config.AmbientColor;
effect.DirectionalLight0.Enabled = true;
effect.DirectionalLight0.Direction = config.Direction;
effect.DirectionalLight0.DiffuseColor = config.DiffuseColor;
effect.DirectionalLight0.SpecularColor = config.SpecularColor * model.specular;
effect.DirectionalLight1.Enabled = true;
effect.DirectionalLight1.DiffuseColor = config.DiffuseColor * 0.7f;
effect.DirectionalLight1.SpecularColor = config.SpecularColor * model.specular;
effect.DirectionalLight2.Enabled = true;
effect.DirectionalLight2.DiffuseColor = config.DiffuseColor * 0.5f;
effect.DirectionalLight2.SpecularColor = config.SpecularColor * model.specular;
effect.SpecularPower = 100;
effect.FogEnabled = config.FogEnabled;
effect.FogStart = config.FogStart;
effect.FogEnd = config.FogEnd;
effect.FogColor = config.ClearColor;
effect.Projection = camera.Projection;
effect.View = camera.View;
effect.World = boneTransform * anim * transform.Frame;
}
private int DestroyUnityComponent <T>(int entityID, ECSComponent component) where T : Component
{
CTransform cTransform = VerifyTransform(component, entityID);
if (cTransform == null)
{
OnComponentDeInitializeFailure(component, "Transform not found.");
return(1);
}
T unityComponent = cTransform.GameObject.GetComponent <T>();
if (component == null)
{
OnComponentDeInitializeFailure(component, "Unity component not found on transform " + typeof(T));
return(1);
}
GameObject.Destroy(unityComponent);
return(0);
}
public static IComponent[] Create(float x, float y, float size)
{
CPosition position = new CPosition(x, y);
CDimension dimension = new CDimension(size, size);
CTransform transform = new CTransform()
{
Rotation = (float)Random.Range(0, System.Math.PI * 2),
RotationOffset = new Vector2(size / 2, size / 2),
};
return(new IComponent[]
{
position,
dimension,
transform,
new CColor(palette[Random.Range(0, palette.Length - 1)]),
new CQuad(),
new CPhysicsBody(Random.RandomVector2(Random.Range(0, 300)), new Vector2(0, 75)),
new CPartitionable()
});
}
/// <summary>Sets up the camera.</summary>
/// <param name="fovDeg">The camera field of view, in degrees.</param>
/// <param name="zNear">The Z-near clip plane, in meters from the camera.</param>
/// <param name="zFar">The Z-far clip plane, in meters from the camera..</param>
private int InitCam(float fovDeg = 60.0f, float zNear = 0.01f, float zFar = 1000.0f)
{
var aspect = Game1.Inst.GraphicsDevice.Viewport.AspectRatio;
var cam = AddEntity();
var fovRad = fovDeg * 2.0f * MathHelper.Pi / 360.0f;
var proj = Matrix.CreatePerspectiveFieldOfView(fovRad, aspect, zNear, zFar);
AddComponent(cam, new CCamera {
ClipProjection = proj,
Projection = proj,
Heading = (float)-Math.Atan2(21f, -9f),
Height = -12,
Distance = 21
});
AddComponent(cam, camera = new CTransform {
Position = new Vector3(9.0f, 12.0f, 21f),
Rotation = Matrix.Identity,
Scale = Vector3.One
});
AddComponent(cam, new CInput());
return(cam);
}
public static void WriteEntityLight(this NetBuffer message, int id, CBody cbody, CTransform cTransform)
{
message.Write(id);
message.Write(cbody.Velocity);
message.Write(cTransform.Position);
message.WriteMatrix(cTransform.Rotation);
}
public override void UpdateEntity(int entity)
{
CBoid boid = (CBoid)boids[entity];
CPosition position = (CPosition)positions[entity];
CDimension dimension = (CDimension)dimensions[entity];
CTransform transform = (CTransform)transforms[entity];
CPhysicsBody physicsBody = (CPhysicsBody)physicsBodies[entity];
Vector2 myCenter = new Vector2(position.X + dimension.Width / 2, position.Y + dimension.Height / 2);
Vector2 cumulativeSeperation = Vector2.Zero;
int totalSeperation = 0;
Vector2 cumulativeAlignment = Vector2.Zero;
int totalAlignment = 0;
Vector2 cumulativeCohesion = Vector2.Zero;
int totalCohesion = 0;
float distance;
CPosition theirPosition;
CDimension theirDimension;
CPhysicsBody theirPhysicsBody;
Vector2 force;
Vector2 theirCenter;
List <int> queryResult = binPartitioner.Query(new Morro.Core.Rectangle(position.X - boid.ViewRadius, position.Y - boid.ViewRadius, dimension.Width + boid.ViewRadius * 2, dimension.Height + boid.ViewRadius * 2));
for (int i = 0; i < queryResult.Count; i++)
{
if (queryResult[i] == entity)
{
continue;
}
theirPosition = (CPosition)positions[queryResult[i]];
theirDimension = (CDimension)dimensions[queryResult[i]];
theirPhysicsBody = (CPhysicsBody)physicsBodies[queryResult[i]];
theirCenter = new Vector2(theirPosition.X + theirDimension.Width / 2, theirPosition.Y + theirDimension.Height / 2);
distance = Vector2.Distance(myCenter, theirCenter);
if (distance > 0)
{
if (distance < boid.ViewRadius)
{
cumulativeCohesion += theirCenter;
totalCohesion++;
cumulativeAlignment += theirPhysicsBody.Velocity;
totalAlignment++;
}
if (distance < theirDimension.Width * 2)
{
force = myCenter - theirCenter;
force /= distance * distance;
cumulativeSeperation += force;
totalSeperation++;
}
if (distance < 64 && theirDimension.Width > 2)
{
force = myCenter - theirCenter;
force /= distance * distance;
cumulativeSeperation += force * 4;
totalSeperation++;
}
}
}
distance = Vector2.Distance(Morro.Input.Mouse.SceneLocation, myCenter);
if (distance > 0 && distance < 32)
{
force = myCenter - Morro.Input.Mouse.SceneLocation;
force /= distance * distance;
cumulativeSeperation += force;
totalSeperation++;
}
Vector2 seperation = CalculateSeperation();
Vector2 alignment = CalculateAlignment();
Vector2 cohesion = CalculateCohesion();
Vector2 totalForce = seperation + alignment + cohesion;
physicsBody.Velocity += totalForce;
transform.Rotation = -(float)Math.Atan2(physicsBody.Velocity.Y, physicsBody.Velocity.X);
Vector2 CalculateSeperation()
{
if (totalSeperation <= 0)
{
return(Vector2.Zero);
}
cumulativeSeperation /= totalSeperation;
cumulativeSeperation.SetMagnitude(boid.MoveSpeed);
Vector2 result = cumulativeSeperation - physicsBody.Velocity;
result.Limit(boid.MaxForce);
return(result * seperationIntensity);
}
Vector2 CalculateAlignment()
{
if (totalAlignment <= 0)
{
return(Vector2.Zero);
}
cumulativeAlignment /= totalAlignment;
cumulativeAlignment.SetMagnitude(boid.MoveSpeed);
Vector2 result = cumulativeAlignment - physicsBody.Velocity;
result.Limit(boid.MaxForce);
return(result * alignmentIntensity);
}
Vector2 CalculateCohesion()
{
if (totalCohesion <= 0)
{
return(Vector2.Zero);
}
cumulativeCohesion /= totalCohesion;
cumulativeCohesion -= myCenter;
cumulativeCohesion.SetMagnitude(boid.MoveSpeed);
Vector2 result = cumulativeCohesion - physicsBody.Velocity;
result.Limit(boid.MaxForce);
return(result * cohesionIntensity);
}
}
/// <summary> Message loop to check type of message and handle it accordingly </summary>
public void MessageLoop()
{
while ((_msg = _peer.ReadMessage()) != null)
{
s_bpsBytes += _msg.LengthBytes;
switch (_msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//Debug.WriteLine("ReceivePeersData DiscoveryRequest");
_peer.SendDiscoveryResponse(null, _msg.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
// just connect to first server discovered
//Debug.WriteLine("ReceivePeersData DiscoveryResponse CONNECT");
if (_peer.Connections.Any(x => x.RemoteEndPoint.Address.Equals(_msg.SenderEndPoint.Address)))
{
Debug.WriteLine("allreadyConnected");
}
else
{
_peer.Connect(_msg.SenderEndPoint);
}
break;
case NetIncomingMessageType.ConnectionApproval:
//Debug.WriteLine("ReceivePeersData ConnectionApproval");
_msg.SenderConnection.Approve();
//broadcast this to all connected clients
SendPeerInfo(_msg.SenderEndPoint.Address, _msg.SenderEndPoint.Port);
break;
case NetIncomingMessageType.Data:
//another client sent us data
//Read TypeData First
Enums.MessageType mType = (Enums.MessageType)_msg.ReadByte();
if (mType == Enums.MessageType.String)
{
var metadata = _msg.ReadString();
if (metadata == "StartEvent")
{
var map = _msg.ReadString();
_isMaster = false;
MasterNetConnection = _peer.Connections.FirstOrDefault(x => x.RemoteEndPoint.Address.ToString() == _msg.SenderEndPoint.Address.ToString());
Game1.Inst.Scene.Raise("startgame", map);
}
else if (metadata == "metadata")
{
Game1.Inst.Scene.Raise("network_data_text", _msg.ReadString());
}
}
else if (mType == Enums.MessageType.PeerInformation)
{
int byteLenth = _msg.ReadInt32();
byte[] addressBytes = _msg.ReadBytes(byteLenth);
IPAddress ip = new IPAddress(addressBytes);
int port = _msg.ReadInt32();
//connect
IPEndPoint endPoint = new IPEndPoint(ip, port);
Debug.WriteLine("Data::PeerInfo::Detecting if we're connected");
if (_peer.GetConnection(endPoint) == null)
{ //are we already connected?
//Don't try to connect to ourself!
if (_peer.Configuration.LocalAddress.GetHashCode() != endPoint.Address.GetHashCode() ||
_peer.Configuration.Port.GetHashCode() != endPoint.Port.GetHashCode())
{
Debug.WriteLine(string.Format("Data::PeerInfo::Initiate new connection to: {0}:{1}", endPoint.Address.ToString(), endPoint.Port.ToString()));
_peer.Connect(endPoint);
}
}
}
else if (mType == Enums.MessageType.Entity || mType == Enums.MessageType.EntityLight)
{
var cbody = new CBody();
var ctransform = new CTransform();
string modelname = "";
bool isPlayer = false;
int id = 0;
id = mType == Enums.MessageType.EntityLight ? _msg.ReadEntityLight(ref cbody, ref ctransform, ref modelname, ref isPlayer) : _msg.ReadEntity(ref cbody, ref ctransform, ref modelname, ref isPlayer);
Game1.Inst.Scene.Raise("entityupdate", new EntitySync {
ID = id, CBody = cbody, CTransform = ctransform, ModelFileName = modelname, IsPlayer = isPlayer
});
}
else if (mType == Enums.MessageType.CTransform)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.Vector3)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.CText)
{
var id = _msg.ReadInt32();
var data = _msg.ReadCText();
Game1.Inst.Scene.Raise("network_menu_data_received", new MenuItem {
CText = data, Id = id
});
}
else if (mType == Enums.MessageType.Int32)
{
var metadata = _msg.ReadString();
var data = _msg.ReadInt32();
if (metadata == "network_game_end")
{
Game1.Inst.Scene.Raise("game_end", data);
}
}
else if (mType == Enums.MessageType.PlayerInfo)
{
var date = _msg.ReadInt64();
if (!players.Any(x => x.IP == _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString()))
{
players.Add(new NetworkPlayer {
IP = _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString(), Time = new DateTime(date), You = false
});
Game1.Inst.Scene.Raise("update_peers", players.OrderBy(x => x.Time).ToList());
}
}
//Console.WriteLine("END ReceivePeersData Data");
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("UnconnectedData: " + _msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
Debug.WriteLine(NetIncomingMessageType.VerboseDebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Debug.WriteLine(NetIncomingMessageType.DebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.WriteLine(NetIncomingMessageType.WarningMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(NetIncomingMessageType.ErrorMessage + " " + _msg.ReadString());
break;
default:
Debug.WriteLine("ReceivePeersData Unknown type: " + _msg.MessageType.ToString());
try
{
Debug.WriteLine(_msg.SenderConnection);
if (_msg.SenderConnection.Status == NetConnectionStatus.Disconnected)
{
//Maybe try to reconnect
}
Debug.WriteLine(_msg.ReadString());
}
catch
{
Debug.WriteLine("Couldn't parse unknown to string.");
}
break;
}
}
}
public static void CreateTriggerEvents(int numTriggers, int worldsize)
{
var currentScene = Game1.Inst.Scene;
Random rnd = new Random();
// TODO: get the global value of the worldsize
for (int i = 0; i < numTriggers; i++)
{
int id = currentScene.AddEntity();
var z = (float)(rnd.NextDouble() * worldsize);
var x = (float)(rnd.NextDouble() * worldsize);
currentScene.AddComponent(id, new CBody()
{
Radius = 5, Aabb = new BoundingBox(new Vector3(-5, -5, -5), new Vector3(5, 5, 5)), LinDrag = 0.8f
});
currentScene.AddComponent(id, new CTransform()
{
Position = new Vector3(x, -50, z), Scale = new Vector3(1f)
});
if (rnd.NextDouble() > 0.5)
{
// Falling balls event
currentScene.OnEvent("collision", data => {
foreach (var player in Game1.Inst.Scene.GetComponents <CPlayer>().Keys)
{
if ((((PhysicsSystem.CollisionInfo)data).Entity1 == player &&
((PhysicsSystem.CollisionInfo)data).Entity2 == id)
||
(((PhysicsSystem.CollisionInfo)data).Entity1 == id &&
((PhysicsSystem.CollisionInfo)data).Entity2 == player))
{
CTransform playerPosition =
(CTransform)currentScene.GetComponentFromEntity <CTransform>(player);
for (var j = 0; j < 6; j++)
{
var r = 0.6f + (float)rnd.NextDouble() * 2.0f;
Utils.SceneUtils.CreateBall(
new Vector3((float)Math.Sin(j) * j + playerPosition.Position.X,
playerPosition.Position.Y + 10f + 2.0f * j,
(float)Math.Cos(j) * j + playerPosition.Position.Z), // Position
new Vector3(0.0f, -50.0f, 0.0f), // Velocity
r); // Radius
//balls.Add(ballId);
}
}
}
});
}
else
{
// Balls spawns around the player
currentScene.OnEvent("collision", data => {
foreach (var player in Game1.Inst.Scene.GetComponents <CPlayer>().Keys)
{
if ((((PhysicsSystem.CollisionInfo)data).Entity1 == player &&
((PhysicsSystem.CollisionInfo)data).Entity2 == id)
||
(((PhysicsSystem.CollisionInfo)data).Entity1 == id &&
((PhysicsSystem.CollisionInfo)data).Entity2 == player))
{
CTransform playerPosition =
(CTransform)currentScene.GetComponentFromEntity <CTransform>(player);
for (var j = 0; j < 6; j++)
{
var r = 0.6f + (float)rnd.NextDouble() * 2.0f;
Utils.SceneUtils.CreateBall(
new Vector3((float)Math.Sin(j) * j + playerPosition.Position.X,
playerPosition.Position.Y + 2f,
(float)Math.Cos(j) * j + playerPosition.Position.Z), // Position
new Vector3(0.0f, 0.0f, 0.0f), // Velocity
r); // Radius
//balls.Add(ballId);
}
}
}
});
}
}
}
public void Run()
{
/*RaycastHit h;
* bool hit = Physics.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Camera.main.transform.forward,out h);*/
if (run)
{
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
RunButtons(hit);
foreach (HorizontalSlider hs in horizontalSliders)
{
hs.valuer.transform.localPosition = new Vector3(Mathf.Clamp(hs.valuer.transform.localPosition.x, hs.left.x, hs.right.x), 0, -0.01f);
if (hit && /*h*/ hit.transform.gameObject == hs.valuer && Input.GetMouseButton(0))
{
hs.drag = true;
}
if (Input.GetMouseButtonUp(0))
{
hs.drag = false;
}
if (hs.drag)
{
hs.value = CalculateValue(hs.left, hs.right, hs.valuer.transform.localPosition);
Vector2 position = Camera.main.ScreenToWorldPoint(Input.mousePosition);
position.y = hs.valuer.transform.position.y;
Vector3 tmp = hs.valuer.transform.localPosition;
//tmp.x = position.x-hs.slider.transform.position.x;
tmp.x += CInput.MouseSpeed().x *Time.deltaTime;
valuerdelta = Input.mousePosition - valuerlastpos;
valuerlastpos = Input.mousePosition;
//tmp.y = position.y-hs.slider.transform.position.y;
hs.valuer.transform.localPosition = tmp;
//hs.valuer.transform.localPosition = new Vector3(hs.valuer.transform.localPosition.x, hs.valuer.transform.localPosition.y, -0.1f);
Debug.Log(hs.value);
hs.valuer.transform.localPosition = new Vector3(Mathf.Clamp(hs.valuer.transform.localPosition.x, hs.left.x, hs.right.x), 0, -0.01f);
}
}
foreach (Label l in labels)
{
if (l.keepInPosition)
{
if (l.target)
{
l.gameObject.GetComponent <RectTransform>().anchoredPosition = CTransform.WorldToScreenPosition(l.target.position, l.canvas.name);
}
else
{
l.gameObject.GetComponent <RectTransform>().anchoredPosition = CTransform.WorldToScreenPosition(l.position, l.canvas.name);
}
}
}
}
else
{
foreach (Button b in buttons)
{
if (b.isClicked)
{
b.isClicked = false;
}
}
}
}
public void DrawScene(CCamera camera, int excludeEid = -1)
{
// TODO: Clean code below up, hard to read.
Game1.Inst.GraphicsDevice.Clear(new Color(Game1.Inst.Scene.LightConfig.ClearColor));
Game1.Inst.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
foreach (CTransform transformComponent in Game1.Inst.Scene.GetComponents <CTransform>().Values)
{
transformComponent.Frame = Matrix.CreateScale(transformComponent.Scale) *
transformComponent.Rotation *
Matrix.CreateTranslation(transformComponent.Position);
}
var numDraws1 = 0;
var numDraws = 0;
var device = Game1.Inst.GraphicsDevice;
var scene = Game1.Inst.Scene;
var frustrum = camera.Frustum;
foreach (var component in scene.GetComponents <C3DRenderable>())
{
numDraws1++;
var key = component.Key;
if (key == excludeEid)
{
// TODO: This is originally a hack to simplify rendering of environment maps.
continue;
}
C3DRenderable model = (C3DRenderable)component.Value;
if (model.model == null)
{
continue; // TODO: <- Should be an error, not silent fail?
}
CTransform transform = (CTransform)scene.GetComponentFromEntity <CTransform>(key);
Matrix[] bones = new Matrix[model.model.Bones.Count];
model.model.CopyAbsoluteBoneTransformsTo(bones);
var anim = Matrix.Identity;
if (model.animFn != null)
{
anim = model.animFn(mT);
}
if (Game1.Inst.Scene.EntityHasComponent <CPlayer>(key))
{
var cp = (CPlayer)Game1.Inst.Scene.GetComponentFromEntity <CPlayer>(key);
if (cp.HitId > 0)
{
var playerData = (CHit)Game1.Inst.Scene.GetComponentFromEntity <CHit>(cp.HitId);
if (playerData.IsAttacking)
{
bones[1] *= Matrix.CreateTranslation(0.0f, 0.5f, 0f);
bones[1] *= Matrix.CreateRotationX(2 * (float)Math.Sin(-playerData.AnimationProgress));
bones[1] *= Matrix.CreateTranslation(0.0f, -0.5f, 0f);
}
}
}
for (int k = 0; k < model.model.Meshes.Count; k++)
{
var mesh = model.model.Meshes[k];
string tag = model.model.Tag as string;
// TODO: This is a really ugly hack. :-(
if (tag != "Heightmap")
{
if (frustrum.Contains(mesh.BoundingSphere.Transform(transform.Frame)) ==
ContainmentType.Disjoint)
{
break;
}
}
Effect lastEffect = null;
for (var i = 0; i < mesh.MeshParts.Count; i++)
{
var part = mesh.MeshParts[i];
if (part.PrimitiveCount == 0)
{
continue;
}
MaterialShader mat = null;
if (model.materials != null)
{
model.materials.TryGetValue(i, out mat);
}
var effect = mat?.mEffect ?? part.Effect;
if (lastEffect != effect)
{
if (mat != null)
{
mat.CamPos = camera.Position;
mat.Model = bones[mesh.ParentBone.Index] * anim * transform.Frame;
mat.View = camera.View;
mat.Proj = camera.Projection;
mat.FogStart = Game1.Inst.Scene.LightConfig.FogStart;
mat.FogEnd = Game1.Inst.Scene.LightConfig.FogEnd;
mat.FogColor = Game1.Inst.Scene.LightConfig.ClearColor;
mat.Prerender();
}
else
{
SetupBasicEffect((BasicEffect)effect,
camera,
model,
scene,
transform,
mesh,
anim,
bones[mesh.ParentBone.Index],
Game1.Inst.Scene.LightConfig);
}
lastEffect = effect;
}
device.SetVertexBuffer(part.VertexBuffer);
device.Indices = part.IndexBuffer;
for (var j = 0; j < effect.CurrentTechnique.Passes.Count; j++)
{
effect.CurrentTechnique.Passes[j].Apply();
numDraws++;
device.DrawIndexedPrimitives(PrimitiveType.TriangleList,
part.VertexOffset,
0,
part.NumVertices,
part.StartIndex,
part.PrimitiveCount);
}
}
}
}
//--------------------
// Billboards
//--------------------
device.SetVertexBuffer(mBillboardVbo);
device.Indices = mBillboardIbo;
var bbMat = mBillboardMat;
var pass0 = bbMat.mEffect.CurrentTechnique.Passes[0];
bbMat.CamPos = camera.Position;
bbMat.Proj = camera.Projection;
bbMat.View = camera.View;
bbMat.FogStart = scene.LightConfig.FogStart;
bbMat.FogEnd = scene.LightConfig.FogEnd;
bbMat.FogColor = scene.LightConfig.ClearColor;
var camPos = camera.Position;
var o = camPos - camera.Target;
o.Normalize();
o *= 2.0f;
foreach (var e in scene.GetComponents <CBillboard>())
{
var bb = (CBillboard)e.Value;
var bbRot = Matrix.CreateBillboard(bb.Pos, camPos + o, Vector3.Up, null);
bbMat.Tex = bb.Tex;
bbMat.Model = Matrix.CreateScale(bb.Scale) * bbRot;
bbMat.Prerender();
pass0.Apply();
device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 4, 0, 2);
}
foreach (var component in scene.GetComponents <CWater>())
{
var model = (C3DRenderable)component.Value;
var key = component.Key;
if (key == excludeEid)
{
// TODO: This is originally a hack to simplify rendering of environment maps.
continue;
}
CTransform transform = (CTransform)scene.GetComponentFromEntity <CTransform>(key);
Matrix[] bones = new Matrix[model.model.Bones.Count];
model.model.CopyAbsoluteBoneTransformsTo(bones);
foreach (var mesh in model.model.Meshes)
{
foreach (ModelMeshPart part in mesh.MeshParts)
{
Matrix world = mesh.ParentBone.Transform * transform.Frame;
part.Effect.Parameters["World"].SetValue(world);
part.Effect.Parameters["View"].SetValue(camera.View);
part.Effect.Parameters["Projection"].SetValue(camera.Projection);
part.Effect.Parameters["CameraPosition"].SetValue(camera.Position);
part.Effect.Parameters["Time"].SetValue(mT);
foreach (var pass in part.Effect.CurrentTechnique.Passes)
{
pass.Apply();
}
mesh.Draw();
}
}
}
// -
}
internal static SchemaShape2D CreateShapeSchema(GeometryData shapeData, CPosition position, CDimension dimension, CTransform transform)
{
Matrix vertexTransform = CreateVertexTransform();
Vector2[] vertices = CreateVertices();
LineSegment[] lineSegments = CreateLineSegments();
return(new SchemaShape2D(vertices, lineSegments));
Matrix CreateVertexTransform()
{
return
(Matrix.CreateScale(dimension.Width * transform.Scale.X, dimension.Height * transform.Scale.Y, 1 * transform.Scale.Z) *
Matrix.CreateTranslation(-new Vector3(transform.RotationOffset.X, transform.RotationOffset.Y, 0)) *
Matrix.CreateRotationZ(transform.Rotation) *
Matrix.CreateTranslation(position.X + transform.Translation.X + transform.RotationOffset.X, position.Y + transform.Translation.Y + transform.RotationOffset.Y, transform.Translation.Z) *
Matrix.Identity);
}
Vector2[] CreateVertices()
{
Vector2[] result = new Vector2[shapeData.TotalVertices];
for (int i = 0; i < shapeData.TotalVertices; i++)
{
result[i] = Vector2.Transform(new Vector2(shapeData.Vertices[i].X, shapeData.Vertices[i].Y), vertexTransform);
}
return(result);
}
LineSegment[] CreateLineSegments()
{
int totalVertices = shapeData.TotalVertices;
LineSegment[] result = new LineSegment[totalVertices];
result[0] = new LineSegment(vertices[totalVertices - 1].X, vertices[totalVertices - 1].Y, vertices[0].X, vertices[0].Y);
for (int i = 1; i < totalVertices; i++)
{
result[i] = new LineSegment(vertices[i - 1].X, vertices[i - 1].Y, vertices[i].X, vertices[i].Y);
}
return(result);
}
}
private NTROValue ReadField(ResourceIntrospectionManifest.ResourceDiskStruct.Field field, bool pointer)
{
switch (field.Type)
{
case DataType.Struct:
var newStruct = Resource.IntrospectionManifest.ReferencedStructs.First(x => x.Id == field.TypeData);
return(new NTROValue <NTROStruct>(field.Type, ReadStructure(newStruct, Reader.BaseStream.Position), pointer));
case DataType.Enum:
// TODO: Lookup in ReferencedEnums
return(new NTROValue <uint>(field.Type, Reader.ReadUInt32(), pointer));
case DataType.SByte:
return(new NTROValue <sbyte>(field.Type, Reader.ReadSByte(), pointer));
case DataType.Byte:
return(new NTROValue <byte>(field.Type, Reader.ReadByte(), pointer));
case DataType.Boolean:
return(new NTROValue <bool>(field.Type, Reader.ReadByte() == 1 ? true : false, pointer));
case DataType.Int16:
return(new NTROValue <short>(field.Type, Reader.ReadInt16(), pointer));
case DataType.UInt16:
return(new NTROValue <ushort>(field.Type, Reader.ReadUInt16(), pointer));
case DataType.Int32:
return(new NTROValue <int>(field.Type, Reader.ReadInt32(), pointer));
case DataType.UInt32:
return(new NTROValue <uint>(field.Type, Reader.ReadUInt32(), pointer));
case DataType.Float:
return(new NTROValue <float>(field.Type, Reader.ReadSingle(), pointer));
case DataType.Int64:
return(new NTROValue <long>(field.Type, Reader.ReadInt64(), pointer));
case DataType.ExternalReference:
var id = Reader.ReadUInt64();
var value = id > 0
? Resource.ExternalReferences?.ResourceRefInfoList.FirstOrDefault(c => c.Id == id)
: null;
return(new NTROValue <ResourceExtRefList.ResourceReferenceInfo>(field.Type, value, pointer));
case DataType.UInt64:
return(new NTROValue <ulong>(field.Type, Reader.ReadUInt64(), pointer));
case DataType.Vector:
var vector3 = new Vector3(
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle());
return(new NTROValue <Vector3>(field.Type, vector3, pointer));
case DataType.Quaternion:
case DataType.Color:
case DataType.Fltx4:
case DataType.Vector4D:
case DataType.Vector4D_44:
var vector4 = new Vector4(
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle());
return(new NTROValue <Vector4>(field.Type, vector4, pointer));
case DataType.String4:
case DataType.String:
return(new NTROValue <string>(field.Type, Reader.ReadOffsetString(Encoding.UTF8), pointer));
case DataType.Matrix3x4:
case DataType.Matrix3x4a:
var matrix3x4a = new Matrix3x4(
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle());
return(new NTROValue <Matrix3x4>(field.Type, matrix3x4a, pointer));
case DataType.CTransform:
var transform = new CTransform(
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle(),
Reader.ReadSingle());
return(new NTROValue <CTransform>(field.Type, transform, pointer));
default:
throw new NotImplementedException($"Unknown data type: {field.Type} (name: {field.FieldName})");
}
}
/// <summary>Checks for and solves collisions against the world bounds.</summary>
/// <param name="eid">The ID of the entity to check.</param>
/// <param name="body">The body component of the entity to check.</param>
/// <param name="transf">The transform component of the entity to check.</param>
/// <param name="aabb">The axis-aligned bounding box component of the entity to check.</param>
private void CheckBodyWorld(int eid, CBody body, CTransform transf, BoundingBox aabb)
{
// This function is pretty trivial, so we can solve the collision immediately - no need to
// store it for solving during the fine-solver phase. Basically, just check the bounding box
// against the world bounds and bounce against them with full restitution. In practice, this
// method should only be used to prevent objects from leaving universe to prevent
// hard-to-detect errors in the physical simulation. Don't use it for in-game mechanics.
if (aabb.Min.X < Bounds.Min.X)
{
transf.Position.X = Bounds.Min.X - body.Aabb.Min.X;
body.Velocity.X *= -body.Restitution;
}
else if (aabb.Max.X > Bounds.Max.X)
{
transf.Position.X = Bounds.Max.X - body.Aabb.Max.X;
body.Velocity.X *= -body.Restitution;
}
if (aabb.Min.Y < Bounds.Min.Y)
{
transf.Position.Y = Bounds.Min.Y - body.Aabb.Min.Y;
body.Velocity.Y *= -body.Restitution;
}
else if (aabb.Max.Y > Bounds.Max.Y)
{
transf.Position.Y = Bounds.Max.Y - body.Aabb.Max.Y;
body.Velocity.Y *= -body.Restitution;
}
if (aabb.Min.Z < Bounds.Min.Z)
{
transf.Position.Z = Bounds.Min.Z - body.Aabb.Min.Z;
body.Velocity.Z *= -body.Restitution;
}
else if (aabb.Max.Z > Bounds.Max.Z)
{
transf.Position.Z = Bounds.Max.Z - body.Aabb.Max.Z;
body.Velocity.Z *= -body.Restitution;
}
// If we have a map system, check that we don't fall below the ground. This part is part of
// game mechanics.
if (Heightmap != null)
{
//sometimes nan Values??
if (double.IsNaN(transf.Position.X))
{
return;
}
var mapHeight = Heightmap.HeightAt(transf.Position.X, transf.Position.Z);
if (aabb.Min.Y < mapHeight)
{
transf.Position.Y = mapHeight - body.Aabb.Min.Y;
body.Velocity.Y *= -body.Restitution;
Scene.Raise("collisionwithground", new CollisionInfo {
Entity1 = eid
});
}
}
}
public void UpdateMouseInputs()
{
float dt = FrameController.DT();
UpdateMousePosition();
if (isPaperHeld || (rcCarScript != null && rcCarScript.isMouseHeld)) // Lock input until paper is put down
{
if (Input.GetTriggered(0, "MouseLClick") == 1.0f)
{
if (rcCarScript != null && rcCarScript.isMouseHeld)
{
rcCarScript.isMouseHeld = false;
}
else
{
pickedInteractable.OnTriggered();
isPaperHeld = false;
}
}
}
else
{
// Apply raycast of ocuPlayer's mouse to find any interactable object every frame (when mouse is not clicked)
Vector3 ocuCamToMouse = (Vector3)gameObject.transform.position - (Vector3)ocuCam.transform.position;
// Quick Hack to fix offset
// Vector3 xAxis = ocuCam.transform.GetRightVector();
// Vector3 yAxis = ocuCam.transform.GetUpVector();
// ocuCamToMouse += xAxis * 0.055f;
// ocuCamToMouse += yAxis * 0.12f;
ocuCamToMouse.Normalize();
if (Input.GetHeld(0, "MouseLClick") == 0.0f)
{
pickedObject = PhysicEngine.getInstance().RayCast3DWithTag(ocuCam.transform.position, ocuCamToMouse, 10000.0f, Common.tagForInteractables);
pickedInteractable = null;
// Check if mouse is over a valid camInMap
if (pickedObject != null)
{
pickedInteractable = GetScriptClass <InteractableObjectBaseClass>(pickedObject, false);
if (pickedInteractable != null)
{
pickedInteractable.OnMouseOver();
// The logic for ray casting through the camera screen into world objects
CameraScreen pickedScreen = pickedInteractable as CameraScreen;
if (pickedScreen != null && camScript.gameObjectParentedTo != null &&
camScript.gameObjectParentedTo != Common.GetNoiseStatic())
{
CTransform screenTrans = pickedScreen.gameObject.transform;
Vector3 screenPos = screenTrans.position;
Vector3 rightVect = screenTrans.GetRightVector();
Vector3 upVect = screenTrans.GetUpVector();
Vector3 normal = screenTrans.GetForwardVector();
Vector3 screenScale = screenTrans.GetScale();
Vector3 pointOnScreen = new Vector3();
MMath.RayToPlaneIntersection(normal, screenPos, ocuCamToMouse, ocuCam.transform.position, ref pointOnScreen);
Vector3 screenToPoint = pointOnScreen - screenPos;
float xAmt = -Vector3.Dot(screenToPoint, rightVect); // the camera screen's x is negative (to the left)
float yAmt = Vector3.Dot(screenToPoint, upVect);
float xScaleOfModel = screenScale.X * 0.5f; // Reflect actual camera screen width in pixel units (quad is just nice 1 scale == 1 unit)
float yScaleOfModel = screenScale.Y * 0.5f;
xAmt /= xScaleOfModel; // [-0.5, 0.5]
yAmt /= yScaleOfModel;
float nearZ = ocuCameraScreen.GetNearZ();
float screenWidth = ocuCameraScreen.GetNearWindowWidth();
float screenHeight = ocuCameraScreen.GetNearWindowHeight();
xAmt *= screenWidth; // [-0.5, 0.5] -> [-w/2, w/2]
yAmt *= screenHeight;
// Use the x, y and z values through the actual camera look at directions
Vector3 innerCameraVect = xAmt * (Vector3)camScript.gameObjectParentedTo.transform.GetRightVector() +
yAmt * (Vector3)camScript.gameObjectParentedTo.transform.GetUpVector() +
nearZ * (Vector3)camScript.gameObjectParentedTo.transform.GetForwardVector();
innerCameraVect.Normalize();
Vector3 cameraPos = camScript.gameObjectParentedTo.transform.position +
0.5f * innerCameraVect; // Move in front, so it does not ray cast to the screen itself
GameObject cameraInteractable = PhysicEngine.getInstance().RayCast3DWithTag(cameraPos, innerCameraVect, 10000.0f, "camInteract");
if (cameraInteractable != null)
{
// If there is an interactable objec through the screen, check if there is ANY object infront of it
GameObject nearestObj = PhysicEngine.getInstance().RayCast3D(cameraPos, innerCameraVect, 10000.0f);
if (nearestObj == cameraInteractable)
{
pickedInteractable = GetScriptClass <InteractableObjectBaseClass>(cameraInteractable, false);
if (pickedInteractable != null)
{
pickedInteractable.OnMouseOver();
}
}
else // There is something blocking
{
Logger.Log("nearer Obj found: " + nearestObj.GetName());
}
}
}
}
}
// If prev interactable changed or is lost, call it's mouseOverOff
if (prevPickedInteractable != pickedInteractable)
{
if (prevPickedInteractable != null)
{
prevPickedInteractable.OnMouseOverOff();
if (Input.GetReleased(0, "MouseLClick") == 1.0f)
{
prevPickedInteractable.OnReleased();
}
}
prevPickedInteractable = pickedInteractable;
}
} // End of if not mouse held
if (Input.GetTriggered(0, "MouseLClick") == 1.0f)
{
if (pickedInteractable != null)
{
pickedInteractable.OnTriggered();
// If picked up paper, lock the input
Paper pickedPaper = pickedInteractable as Paper;
if (pickedPaper != null)
{
if (pickedPaper.GetIsHeldUp())
{
isPaperHeld = true;
}
}
}
}
if (Input.GetHeld(0, "MouseLClick") == 1.0f)
{
if (pickedInteractable != null)
{
pickedInteractable.OnHeldMouse(mCurrMouseMovement.X, mCurrMouseMovement.Y);
}
}
if (Input.GetReleased(0, "MouseLClick") == 1.0f)
{
if (pickedInteractable != null)
{
pickedInteractable.OnReleased();
}
}
}
}
private void createEnvMapping()
{
C3DRenderable model = null;
CTransform transform = null;
foreach (var component in Game1.Inst.Scene.GetComponents <C3DRenderable>())
{
var key = component.Key;
model = (C3DRenderable)component.Value;
if (model.effect == null)
{
continue;
}
transform = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(key);
}
RenderTarget2D renderTarget = new RenderTarget2D(Game1.Inst.GraphicsDevice, 256, 256);
Game1.Inst.GraphicsDevice.Clear(Color.Black);
Matrix view = Matrix.Identity;
for (int i = 0; i < 6; i++)
{
// render the scene to all cubemap faces
CubeMapFace cubeMapFace = (CubeMapFace)i;
switch (cubeMapFace)
{
case CubeMapFace.NegativeX:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Left, Vector3.Up);
break;
}
case CubeMapFace.NegativeY:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Down, Vector3.Forward);
break;
}
case CubeMapFace.NegativeZ:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Backward, Vector3.Up);
break;
}
case CubeMapFace.PositiveX:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Right, Vector3.Up);
break;
}
case CubeMapFace.PositiveY:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Up, Vector3.Backward);
break;
}
case CubeMapFace.PositiveZ:
{
view = Matrix.CreateLookAt(transform.Position, Vector3.Forward, Vector3.Up);
break;
}
}
// Set the cubemap render target, using the selected face
Game1.Inst.GraphicsDevice.SetRenderTarget(renderTarget);
Game1.Inst.GraphicsDevice.Clear(Color.White);
drawNormal(view);
//skysystem.DrawOnRequest(view);
Color[] colordata = new Color[256 * 256];
renderTarget.GetData(colordata);
model.environmentMap.SetData((CubeMapFace)i, colordata);
//DEBUG
Stream stream = File.Create("test" + i + ".jpg");
renderTarget.SaveAsJpeg(stream, 256, 256);
stream.Dispose();
// restore our matrix after changing during the cube map rendering
//view = Matrix.CreateLookAt(new Vector3(0, 0, 0), Vector3.Zero, Vector3.Up);
}
Game1.Inst.GraphicsDevice.SetRenderTarget(null);
}
public static void CreateAnimals(int numFlocks, int worldsize)
{
var currentScene = Game1.Inst.Scene;
int membersPerFlock = (int)(rnd.NextDouble() * 10) + 10;
var flockRadius = membersPerFlock;
for (int f = 0; f < numFlocks; f++)
{
int flockId = currentScene.AddEntity();
CFlock flock = new CFlock {
Radius = 20,
SeparationDistance = 3,
AlignmentFactor = 0.1f,
CohesionFactor = 0.5f,
SeparationFactor = 100.0f,
PreferredMovementSpeed = 150f
};
double animal = rnd.NextDouble();
string flockAnimal = animal > 0.66 ? "flossy" : animal > 0.33 ? "goose" : "hen";
string deathSound = string.Format("Sounds/Effects/{0}", (flockAnimal == "flossy" ? "SheepDeath" : flockAnimal == "goose" ? "GooseDeath" : "DeathChicken"));
int flockX = (int)(rnd.NextDouble() * worldsize * 2 - worldsize);
int flockZ = (int)(rnd.NextDouble() * worldsize * 2 - worldsize);
CTransform flockTransform = new CTransform {
Position = new Vector3(flockX, 0, flockZ)
};
for (int i = 0; i < membersPerFlock; i++)
{
int id = currentScene.AddEntity();
var npcAnim = wiggleAnimation(id);
if (flockAnimal.Equals("hen"))
{
// TODO: Make animals have different animations based on state
CAnimation normalAnimation = new CHenNormalAnimation {
animFn = npcAnim
};
// Set a random offset to animation so not all animals are synced
normalAnimation.CurrentKeyframe = rnd.Next(normalAnimation.Keyframes.Count - 1);
// Random animation speed between 0.8-1.0
normalAnimation.AnimationSpeed = (float)rnd.NextDouble() * 0.2f + 0.8f;
currentScene.AddComponent <C3DRenderable>(id, normalAnimation);
}
else
{
CImportedModel modelComponent = new CImportedModel {
animFn = npcAnim
};
modelComponent.fileName = flockAnimal;
modelComponent.model = Game1.Inst.Content.Load <Model>("Models/" + modelComponent.fileName);
currentScene.AddComponent <C3DRenderable>(id, modelComponent);
}
float memberX = flockTransform.Position.X + (float)rnd.NextDouble() * flockRadius * 2 - flockRadius;
float memberZ = flockTransform.Position.Z + (float)rnd.NextDouble() * flockRadius * 2 - flockRadius;
float y = flockTransform.Position.Y;
CTransform transformComponent = new CTransform();
transformComponent.Position = new Vector3(memberX, y, memberZ);
transformComponent.Rotation = Matrix.CreateFromAxisAngle(Vector3.UnitY,
(float)(Math.PI * (rnd.NextDouble() * 2)));
float size = 0.5f;
transformComponent.Scale = new Vector3(1f);
currentScene.AddComponent(id, transformComponent);
currentScene.AddComponent(id, new CBody {
InvMass = 0.05f,
Aabb = new BoundingBox(-size * new Vector3(1.0f, 2.0f, 1.0f), size * new Vector3(1.0f, 0.0f, 1.0f)),
LinDrag = 0.8f,
Velocity = Vector3.Zero,
Radius = 1f,
SpeedMultiplier = size,
MaxVelocity = 4,
Restitution = 0
});
// health value of npcs, maybe change per species/flock/member?
var npcHealth = 1;
currentScene.AddComponent(id, new CHealth {
MaxHealth = npcHealth, Health = npcHealth, DeathSound = deathSound
});
currentScene.AddComponent(id, new CAI {
Flock = flockId
});
currentScene.AddComponent(id, new CSyncObject());
flock.Members.Add(id);
}
currentScene.AddComponent(flockId, flock);
currentScene.AddComponent(flockId, flockTransform);
}
}
public void drawNormal(Matrix view)
{
Game1.Inst.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
int counter = 0;
foreach (CCamera camera in Game1.Inst.Scene.GetComponents <CCamera>().Values)
{
foreach (var component in Game1.Inst.Scene.GetComponents <C3DRenderable>())
{
var key = component.Key;
C3DRenderable model = (C3DRenderable)component.Value;
if (model.model == null)
{
continue;
}
CTransform transform = (CTransform)Game1.Inst.Scene.GetComponentFromEntity <CTransform>(key);
var objectWorld = transform.ObjectWorld;
foreach (ModelMesh modelMesh in model.model.Meshes)
{
{
if (model.effect != null)
{
if (view.Equals(Matrix.Identity))
{
view = camera.View;
}
foreach (ModelMeshPart part in modelMesh.MeshParts)
{
part.Effect = model.effect;
part.Effect.Parameters["World"].SetValue(modelMesh.ParentBone.Transform * objectWorld * world);
part.Effect.Parameters["View"].SetValue(view);
part.Effect.Parameters["Projection"].SetValue(camera.Projection);
part.Effect.Parameters["AmbientColor"].SetValue(Color.White.ToVector3());
part.Effect.Parameters["AmbientIntensity"].SetValue(0.1f);
part.Effect.Parameters["LightDirection"].SetValue(new Vector3(0, 1f, 0));
part.Effect.Parameters["SpecularPower"].SetValue(400f);
part.Effect.Parameters["SpecularColor"].SetValue(Color.Gray.ToVector3());
part.Effect.Parameters["SpecularIntensity"].SetValue(3.0f);
part.Effect.Parameters["ViewVector"].SetValue(viewVector);
part.Effect.Parameters["ModelTexture"].SetValue(model.texture);
part.Effect.Parameters["BumpConstant"].SetValue(1f);
part.Effect.Parameters["NormalMap"].SetValue(model.normalMap);
part.Effect.Parameters["EnvTexture"].SetValue(model.environmentMap);
}
modelMesh.Draw();
}
if (model.effect == null)
{
foreach (BasicEffect effect in modelMesh.Effects)
{
effect.World = modelMesh.ParentBone.Transform * objectWorld * world;
effect.View = camera.View;
effect.Projection = camera.Projection;
effect.EnableDefaultLighting();
effect.LightingEnabled = true;
effect.DirectionalLight0.DiffuseColor = new Vector3(1f, 1f, 1f);
effect.DirectionalLight0.Direction = new Vector3(-0.5f, 1f, -3.5f);
effect.DirectionalLight0.SpecularColor = new Vector3(-0.1f, -0.1f, -0.1f);
foreach (EffectPass p in effect.CurrentTechnique.Passes)
{
p.Apply();
modelMesh.Draw();
}
}
}
}
}
}
}
}
