public static void CalculateGravityAtAvatar()
{
//Console.WriteLine("Update");
Vector3d g = GetGravityVector(Globals.Avatar.GetPosition());
if (Globals.Avatar.Target == null)
{
g = GetGravityVector(MassiveTools.VectorFromArray(Globals.UserAccount.CurrentPosition));
}
MPhysics.Instance.SetGravity(g);
Globals.LocalUpVector = -g.Normalized();
if (double.IsNaN(Globals.LocalUpVector.X))
{
if (Globals.Avatar.Target != null)
{
Globals.LocalUpVector = Globals.Avatar.Target.transform.Up();
}
}
if (double.IsNaN(g.X))
{
g = new Vector3d(0, -0.8, 0);
}
Globals.LocalGravity = g;
}
private void Network_TextureHandler(object sender, Massive.Events.TextureEvent e)
{
MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(e.InstanceID);
MObject o = MScene.MaterialRoot.FindModuleByName(e.TextureID);
if (o != null && o.Type == MObject.EType.Material)
{
MMaterial mat = (MMaterial)o;
mo.SetMaterial(mat);
}
else
{
if (MassiveTools.IsURL(e.TextureID))
{
MMaterial mat = (MMaterial) new MMaterial("URLShader");
MShader DefaultShader = (MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER);
mat.AddShader(DefaultShader);
mat.ReplaceTexture(Globals.TexturePool.GetTexture(e.TextureID));
MScene.MaterialRoot.Add(mat);
mo.SetMaterial(mat);
mo.material.Setup();
MMessageBus.ChangedTexture(this, e.InstanceID, e.TextureID);
}
else
{
Console.WriteLine("Object " + e.InstanceID + " was null");
MMessageBus.Error(this, "Could not find Material:" + e.TextureID);
}
}
}
void SetMaterial(MSceneObject mo, string sMaterialID)
{
if (sMaterialID == null)
{
sMaterialID = MMaterial.DEFAULT_MATERIAL;
}
//MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(e.InstanceID);
MObject o = MScene.MaterialRoot.FindModuleByName(sMaterialID);
MMaterial mat = null;
if (o != null && o.Type == MObject.EType.Material)
{
mat = (MMaterial)o;
if (mat != null)
{
mo.SetMaterial(mat);
mat.MaterialID = sMaterialID;
}
}
if (MassiveTools.IsURL(sMaterialID))
{
mat = (MMaterial) new MMaterial("URLShader");
MShader DefaultShader = (MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER);
mat.AddShader(DefaultShader);
mat.ReplaceTexture(Globals.TexturePool.GetTexture(sMaterialID));
mat.MaterialID = sMaterialID;
MScene.MaterialRoot.Add(mat);
mo.SetMaterial(mat);
mo.material.Setup();
}
}
private void MMessageBus_ChangeAvatarRequestHandler(object sender, ChangeAvatarEvent e)
{
MBuildingBlock bb = MBuildParts.GetBlock(e.TemplateID);
if (bb == null)
{
Console.WriteLine("MSpawnHandler: Missing Template:" + e.TemplateID);
return;
}
MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(e.UserID);
if (mo != null)
{
MMessageBus.DeleteRequest(this, mo);
}
MServerObject m = new MServerObject();
m.InstanceID = e.UserID;
m.TemplateID = e.TemplateID;
m.OwnerID = e.UserID;
m.TextureID = bb.MaterialID;
m.Name = Globals.UserAccount.UserName;
MScene.Camera.CameraOffset = MassiveTools.VectorFromArray(bb.BoneOffset);
m.Position = Globals.UserAccount.CurrentPosition;
m.Rotation = MassiveTools.ArrayFromQuaterniond(Globals.Avatar.GetRotation());
Spawn(m);
}
void Go()
{
string sText = SiteBox.Text;
if (string.IsNullOrEmpty(sText))
{
return;
}
sText = sText.Trim();
SiteBox.Text = sText;
Vector3d dest = Decoder.Decode(sText);
if (Globals.Network.Connected == true)
{
MMessageBus.TeleportRequest(this, dest, Globals.LocalUpRotation());
}
else
{
MScene.Camera.transform.Position = dest;
Globals.UserAccount.CurrentPosition = MassiveTools.ArrayFromVector(dest);
Globals.Avatar.SetPosition(dest);
MMessageBus.AvatarMoved(this, Globals.UserAccount.UserID, dest, Quaterniond.Identity);
}
MMessageBus.Navigate(this, dest);
}
void DebugBones(Matrix4d viewproj, Matrix4d parentmodel, Matrix4x4[] transforms)
{
if (Globals.RenderPass != Globals.eRenderPass.ShadowDepth)
{
GL.Clear(ClearBufferMask.DepthBufferBit);
Vector3d v = Globals.Avatar.GetPosition();
Vector3d v1 = Vector3d.Zero;
Vector3d v2 = Vector3d.Zero;
// _debug.UserColorCoding = true;
Matrix4 test = Matrix4.CreateTranslation(0, 0.5f, 0);
float f = 0;
for (int i = 0; i < m_bone_matrices.Count; i++)
{
//(MBone b in Bones)
f += 0.1f;
v1 = v2;
v2 = MassiveTools.Vector3dFromVector3(
TKMatrix(transforms[i]).ExtractTranslation()
);
Vector3d r1 = v1 + v;
Vector3d r2 = v2 + v;
// _debug.DrawLine(ref r1, ref r2, i == 0 ? OpenTK.Graphics.Color4.Red : OpenTK.Graphics.Color4.White);
}
// _debug.Render(viewproj, parentmodel);
}
}
void CheckSetupComplete()
{
if (Globals.Tasks <= 0)
{
MStateMachine.ChangeState(MStateMachine.eStates.Viewing);
MPlanetHandler.GetUpAt(MassiveTools.VectorFromArray((Globals.UserAccount.CurrentPosition)));
CreateAvatar();
}
}
public static Vector3d GetDestination(MSceneObject mo)
{
Vector3d dest = Vector3d.Zero;
string[] tags = DecodeTag((string)mo.Tag);
string sDest = tags[1];
MassiveTools.VectorFromString(sDest);
return(dest);
}
void CheckSetupComplete()
{
if (Globals.Tasks <= 0)
{
MStateMachine.ChangeState(MStateMachine.eStates.Viewing);
MPlanetHandler.GetUpAt(MassiveTools.VectorFromArray((Globals.UserAccount.CurrentPosition)));
MMessageBus.GravityStateChanged(this, new BooleanEvent(true));
CreateAvatar();
}
}
private void MMessageBus_BookmardAddRequestEvent(object sender, BookmarkEvent e)
{
MBookmark b = new MBookmark();
b.Name = e.Name;
b.Position = MassiveTools.ArrayFromVector(e.Position);
b.Rotation = MassiveTools.ArrayFromQuaterniond(e.Rotation);
Bookmarks.Add(b);
Save();
MMessageBus.BookmarkAdded(this, e);
}
private void MMessageBus_ZoneSelectHandler(object sender, ZoneEvent e)
{
if (e.Zone == null)
{
Widget.Enabled = false;
}
else
{
Target = MassiveTools.Vector3dFromVector3_Server(e.Zone.Position);
Widget.Enabled = true;
}
}
private void setGPSToolStripMenuItem_Click(object sender, EventArgs e)
{
Button b = (Button)contextMenuStrip1.SourceControl;
if (b != null)
{
MBookmark bm = (MBookmark)b.Tag;
if (bm != null)
{
MMessageBus.Navigate(this, MassiveTools.VectorFromArray(bm.Position));
}
}
}
public void PlaceInstances(Vector3d Anchorpoint)
{
//DistanceThreshold = tile.DistanceThreshold;
this.transform.Position = Anchorpoint;
Random ran = new Random(1234);
Matrix4d TreeRotation = Matrix4d.CreateFromQuaternion(Globals.LocalUpRotation());
int i = 0;
for (int z = 0; z < 30; z++)
{
for (int x = 0; x < 30; x++)
{
if (i >= MaxInstances)
{
break;
}
//Vector3d pos = new Vector3d(1000 * ran.NextDouble(), 200 * ran.NextDouble(), 1000 * ran.NextDouble());
Vector3d pos = MassiveTools.RandomPointInSphere(Vector3d.Zero, 1000, ran);
//Vector3d PlantingPos = planet.GetNearestPointOnSphere(SeedPos + Treepos, 0) - SeedPos;
double scale = MinSize + ran.NextDouble() * (MaxSize - MinSize);
Matrix4d TreeScale = Matrix4d.Scale(scale, scale, scale);
Matrix4d TreePosition = Matrix4d.CreateTranslation(pos);
TreeRotation = Matrix4d.CreateFromQuaternion(
Quaterniond.FromEulerAngles(
ran.NextDouble(),
ran.NextDouble(),
ran.NextDouble()));
//find point at y with raycast
Matrix4 final = MTransform.GetFloatMatrix(TreeScale * TreeRotation * TreePosition);
mats[i] = final;
i++;
}
}
TotalInstances = i;
//null out the remainder
for (int j = TotalInstances; j < MaxInstances; j++)
{
Matrix4 final = Matrix4.Identity;
mats[j] = final;
}
Planted = false;
}
public void Setup(MObject o)
{
MSceneObject mo = (MSceneObject)o;
if (mo == null)
{
return;
}
InstanceID = mo.InstanceID;
Destination = MTeleporter.GetDestination(mo);
DestinationBox.Text = MassiveTools.VectorToString(Destination);
Description = MTeleporter.GetDescription(mo);
DescriptionBox.Text = Description;
}
public static Vector3d Find(string s)
{
Vector3d pos = Vector3d.Zero;
lock (ZoneLocker)
{
MServerZone zone = Zones.Find(x => x.Name.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1);
if (zone != null)
{
pos = MassiveTools.Vector3dFromVector3_Server(zone.Position);
}
}
return(pos);
}
void Add(MBuildingBlock bb)
{
LastBuild = bb;
if (MStateMachine.ZoneLocked == true)
{
MMessageBus.Error(this, "Can't build here, zone is locked / other building nearby");
return;
}
Vector3d pos = Globals.Avatar.GetPosition();
if (bb.TemplateID.Equals(MBuildParts.FOUNDATION01))
{
pos += Globals.Avatar.Forward() * 13 - Globals.Avatar.Up() * 1.0;
}
else
{
pos += Globals.Avatar.Forward() * 4 + Globals.Avatar.Up() * 3.0;
}
Quaterniond rot = Globals.LocalUpRotation();
if (SelectedItem != null)
{
rot = SelectedItem.transform.Rotation;
//prevent smaller items getting lost in the foundation
if (SelectedItem.TemplateID != MBuildParts.FOUNDATION01)
{
//pos = SelectedItem.transform.Position;
}
}
if (Globals.Network.Connected == true)
{
Globals.Network.SpawnRequest(bb.TemplateID, "TEXTURE01", bb.TemplateID, bb.TemplateID, pos, rot);
}
else
{
MServerObject mso = new MServerObject();
mso.InstanceID = Helper.GUID();
mso.OwnerID = Globals.UserAccount.UserID;
mso.TextureID = bb.TextureID;
mso.TemplateID = bb.TemplateID;
mso.Position = MassiveTools.ArrayFromVector(pos);
mso.Rotation = MassiveTools.ArrayFromQuaterniond(rot);
MMessageBus.CreateObjectRequest(this, mso);
}
}
/// <summary>
/// Prepares an object for inclusion in the scene graph
/// If the template does not exist, it is created first
/// </summary>
/// <param name="m"></param>
public void Spawn(MServerObject m)
{
MSceneObject mo = (MSceneObject)MScene.ModelRoot.FindModuleByInstanceID(m.InstanceID);
if (mo != null)
{
return; //if the object already exists, never mind
}
//check if the object template exists. All user objects must exist as a template first
MSceneObject mt = (MSceneObject)MScene.TemplateRoot.FindModuleByName(m.TemplateID);
if (mt == null)
{
LoadTemplate(m.TemplateID);
}
//if ((m.Name == Globals.UserAccount.UserID) && ( m.OwnerID == Globals.UserAccount.UserID)){
mo = Helper.Spawn(m,
MassiveTools.VectorFromArray(m.Position),
MassiveTools.QuaternionFromArray(m.Rotation));
if (mo == null)
{
Console.WriteLine("MSpawnHandler: Template not found:" + m.TemplateID);
}
else
{
mo.InstanceID = m.InstanceID;
mo.SetRotation(MassiveTools.QuaternionFromArray(m.Rotation));
//If the object spawning is our avatar
if (mo.InstanceID == Globals.UserAccount.UserID)
{
Globals.Avatar.SetSceneObject(mo);
MBuildingBlock bb = MBuildParts.GetBlock(mo.TemplateID);
MScene.Camera.CameraOffset = MassiveTools.VectorFromArray(bb.BoneOffset);
MMessageBus.AvatarChanged(this, Globals.UserAccount.UserID, mo.TemplateID);
}
SetMaterial(mo, m.TextureID);
MMessageBus.Created(this, mo);
}
if (mo.OwnerID == Globals.UserAccount.UserID)
{
MMessageBus.Select(this, new SelectEvent(mo));
}
}
//2 user logs in, gets a userID, ends up here
private void MMessageBus_LoggedIn(object sender, ChangeDetailsEvent e)
{
ParseCmdLine();
Globals.Network.GetWorld();
//TODO: Use Server-side home position
Vector3d Home = MassiveTools.VectorFromArray(Globals.UserAccount.HomePosition);
//Globals.UserAccount.HomePosition = MassiveTools.ArrayFromVector(Home);
Globals.Network.SpawnRequest(Globals.UserAccount.AvatarID, MTexture.DEFAULT_TEXTURE, Globals.UserAccount.UserID, "TAG",
Home, Quaterniond.Identity, Globals.UserAccount.UserID, 0, 10);
Globals.Network.ChangeAvatarRequest(Globals.UserAccount.UserID, Globals.UserAccount.AvatarID);
//12717655889.4, 146353256822.3, -7581841339.4(18.4096672612293, -33.9328163657347, 0)
Globals.Network.TeleportRequest(Globals.UserAccount.UserID, Home,
Quaterniond.Identity);
}
/// <summary>
///
/// </summary>
/// <param name="pt">an x z index to a vertex (0-255)</param>
/// <returns></returns>
public Vector3d GetPointOnSurfaceFromGrid(Vector3d grid)
{
int index = (int)(grid.Z * z_res + grid.X);
if (index >= Vertices.Length)
{
index = 0;
}
if (index < 0)
{
index = 0;
}
Vector3d pi = MassiveTools.Vector3dFromVector3(Vertices[index]._position);
//Vector3d zpl = Vector3d.Lerp(Boundary.TL, Boundary.BL, pt.Z);
//Vector3d zpr = Vector3d.Lerp(Boundary.TR, Boundary.BR, pt.Z);
//Vector3d p = Vector3d.Lerp(zpr, zpl, pt.X ) - transform.Position;
return(pi);
}
private void HomeButton_Click(object sender, EventArgs e)
{
MServerZone zone = MZoneService.Find("Earth");
//Vector3d pos = MassiveTools.Vector3dFromVector3_Server(zone.Position);
//cape town
Vector3d pos = MassiveTools.VectorFromArray(Globals.UserAccount.HomePosition);
if (Globals.Network.Connected == true)
{
MMessageBus.TeleportRequest(Globals.UserAccount.UserID, pos, Quaterniond.Identity);
}
else
{
MScene.Camera.transform.Position = pos;
Globals.UserAccount.CurrentPosition = MassiveTools.ArrayFromVector(pos);
Globals.Avatar.SetPosition(pos);
MMessageBus.AvatarMoved(this, Globals.UserAccount.UserID, pos, Quaterniond.Identity);
}
}
private void UpdatePropertiesButton_Click(object sender, EventArgs e)
{
if (Success == true)
{
Globals.Network.PropertyChangeHandler -= Network_PropertyChangeHandler;
Close();
}
if (string.IsNullOrEmpty(DestinationBox.Text))
{
return;
}
Destination = MassiveTools.VectorFromString(DestinationBox.Text);
string DestString = Destination.ToString();
DestString = DestString.Replace("(", "");
DestString = DestString.Replace(")", "");
DestString = DestString.Replace(" ", "");
Description = DescriptionBox.Text;
Globals.Network.ChangePropertyRequest(InstanceID, MBuildParts.TELEPORT01 + "|" + DestString + "|" + Description);
}
private void AstroBodies_SelectedIndexChanged(object sender, EventArgs e)
{
CurrentBody = (MAstroBody)AstroBodies.SelectedItem;
//string sPath =
string sPath = CurrentBody.TextureName;
if (MassiveTools.IsURL(sPath))
{
string cache = MassiveTools.GetCachePath(sPath);
if (!File.Exists(cache))
{
return;
}
bmp = Image.FromFile(cache);
MapBox.BackgroundImage = bmp;
}
else
{
bmp = Image.FromFile(Path.Combine(MFileSystem.AssetsPath, CurrentBody.TextureName));
MapBox.BackgroundImage = bmp;
}
}
void ApplyHeightMap()
{
//Random r = new Random(123);
int i = 0;
double d = z_res / (z_res + 1);
for (int y = 0; y < z_res; y++)
{
//for (int x = -x_res / 2; x < x_res / 2; x++)
for (int x = 0; x < x_res; x++)
{
int pos = y * x_res + x;
float height = HeightColorToHeight(x, y);
Vector3d normal = MassiveTools.Vector3dFromVector3(Vertices[i]._position) + transform.Position - CurrentBody.Position;
normal.Normalize();
Vertices[i]._position += MassiveTools.Vector3FromVector3d(normal) * height;
Vertices[i]._normal = MassiveTools.Vector3FromVector3d(normal);
heights[x, y] = height;
///Vertices[i]._position.Y = HeightColorToHeight(x, y);
i++;
}
}
}
private void But_Click(object sender, EventArgs e)
{
Button b = (Button)sender;
MBookmark bm = (MBookmark)b.Tag;
if (bm != null)
{
if (Globals.Network.Connected == true)
{
MMessageBus.TeleportRequest(this,
MassiveTools.VectorFromArray(bm.Position),
MassiveTools.QuaternionFromArray(bm.Rotation));
}
else
{
MScene.Camera.transform.Position = MassiveTools.VectorFromArray(bm.Position);
Globals.UserAccount.CurrentPosition = bm.Position;
Globals.Avatar.SetPosition(MScene.Camera.transform.Position);
MMessageBus.AvatarMoved(this, Globals.UserAccount.UserID,
MScene.Camera.transform.Position,
MassiveTools.QuaternionFromArray(bm.Rotation));
}
}
}
//TODO: Make work
public void Render(Matrix4d viewproj, Matrix4d parentmodel)
{
Vector3[] positionArray = new Vector3[lines.Count];
Vector4[] colorArray = new Vector4[lines.Count];
int i;
//Random r = new Random();
if (lines.Count() == 0)
{
return;
}
for (i = 0; i < lines.Count; i++)
{
positionArray[i] = MassiveTools.Vector3FromVector3d(lines[i].Position - Globals.GlobalOffset);
colorArray[i] = lines[i].Color;
}
lines.Clear();
vertexCount = positionArray.Length;
//GL.ClearColor(new Color4(0, 0, 0, 0.5f));
//GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Matrix4 mvp = MTransform.GetFloatMatrix(viewproj);
Matrix4 model = MTransform.GetFloatMatrix(parentmodel);
GL.UseProgram(shaderProgram);
int loc = GL.GetUniformLocation(shaderProgram, "mvp");
GL.UniformMatrix4(loc, false, ref mvp);
loc = GL.GetUniformLocation(shaderProgram, "model");
GL.UniformMatrix4(loc, false, ref model);
lineVertexBuffer = GL.GenBuffer();
if (Globals.Avatar.Target == null)
{
return;
}
Vector3 tp = MassiveTools.Vector3FromVector3d(Globals.Avatar.Target.transform.Position);
//Vector3[] lineVertices = { new Vector3(0, 0, 0), new Vector3((float)r.NextDouble(), .5f, 0.5f) - MassiveTools.FromV3d(Globals.GlobalOffset)};
//vertexCount = lineVertices.Length;
GL.BindBuffer(BufferTarget.ArrayBuffer, lineVertexBuffer);
GL.BufferData(BufferTarget.ArrayBuffer, System.Runtime.InteropServices.Marshal.SizeOf(positionArray[0]) * vertexCount,
positionArray, BufferUsageHint.StreamDraw);
vertexInfo = GL.GenVertexArray();
GL.BindVertexArray(vertexInfo);
int locVPosition = GL.GetAttribLocation(shaderProgram, "vPosition");
GL.EnableVertexAttribArray(locVPosition);
GL.VertexAttribPointer(locVPosition, 3, VertexAttribPointerType.Float, false,
System.Runtime.InteropServices.Marshal.SizeOf(positionArray[0]), 0);
//GL.BindVertexArray(0);
//GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
//GL.UseProgram(0);
//GL.ClearColor(Color4.Black);
GL.Clear(ClearBufferMask.DepthBufferBit);
int loca = GL.GetUniformLocation(shaderProgram, "mcolor");
if (UserColorCoding == true)
{
for (int ri = 0; ri <= positionArray.Count() - 2; ri += 2)
{
Vector4 v = colorArray[ri];
GL.Uniform4(loca, ref v);
GL.DrawArrays(PrimitiveType.LineStrip, ri, 2);
}
}
else
{
Vector4 v = new Vector4(1, 1, 1, 0.9f);
GL.Uniform4(loca, ref v);
GL.DrawArrays(PrimitiveType.LineStrip, 0, positionArray.Count());
}
//GL.DrawArrays(PrimitiveType.LineStrip, ri, vertexCount);
GL.BindVertexArray(0);
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.UseProgram(0);
}
private void MMessageBus_ZoneSelectHandler(object sender, ZoneEvent e)
{
NavigationTarget = MassiveTools.Vector3dFromVector3_Server(e.Zone.Position);
}
private void MMessageBus_LoggedIn(object sender, ChangeDetailsEvent e)
{
NavigationTarget = MassiveTools.VectorFromArray(Globals.UserAccount.HomePosition);
}
public static MSceneObject LoadTemplate(string TemplateID)
{
MBuildingBlock bb = MBuildParts.GetBlock(TemplateID);
if (bb == null)
{
Console.WriteLine("WARNING: MSpawnHandler.LoadTemplate " + TemplateID + " not found in blocks");
return(null);
}
MSceneObject o = null;
if (bb.Type == MBuildParts.MAnimatedModel)
{
o = Helper.CreateAnimatedModel(MScene.TemplateRoot, TemplateID, bb.Model, Vector3d.Zero);
MAnimatedModel man = (MAnimatedModel)o;
man.BoneOffset = MassiveTools.VectorFromArray(bb.BoneOffset);
}
if (bb.Type == MBuildParts.MModel)
{
o = Helper.CreateModel(MScene.TemplateRoot, TemplateID, bb.Model, Vector3d.Zero);
}
MMaterial mat = (MMaterial)MScene.MaterialRoot.FindModuleByName(bb.MaterialID);
if (mat == null)
{
Console.WriteLine("MSpawnHandler.LoadTemplate " + bb.MaterialID + " was null");
}
o.SetMaterial(mat);
Vector3d size = MassiveTools.VectorFromArray(bb.Size);
MPhysicsObject.EShape shape = GetShape(bb.PhysicsShape);
if (shape != MPhysicsObject.EShape.NULL)
{
MPhysicsObject mpo = new MPhysicsObject(o, TemplateID + "_physics", bb.Weight, shape,
true, size);
mpo.SetSleep(5);
mpo.SetFriction(0.5);
if (shape != MPhysicsObject.EShape.Sphere)
{
mpo.SetAngularFactor(0.0, 0.0, 0.0);
mpo.SetDamping(0.5, 0.5);
mpo.SetRestitution(0.5);
}
else
{
mpo.SetDamping(0.1, 0.1);
mpo.SetRestitution(0.8);
}
}
o.TemplateID = TemplateID;
o.InstanceID = TemplateID;
o.IsTransparent = bb.IsTransparent;
o.transform.RotationOffset = Quaterniond.FromEulerAngles(MassiveTools.VectorFromArray(bb.RotationOffset));
o.Setup();
AddSubmodules(bb, o);
return(o);
}
public void InitializePlanets()
{
//GravityIndicator = Helper.CreateCube(MScene.AstroRoot, "GravitySphere", Vector3d.Zero);
//GravityIndicator.transform.Scale = new Vector3d(0.05, 0.1, 0.1);
//GravityIndicator.OwnerID = "MasterAstronomer";
//MScene.AstroRoot.Add(GravityIndicator);
//GravityIndicator.SetMaterial((MMaterial)MScene.MaterialRoot.FindModuleByName(MMaterial.DEFAULT_MATERIAL));
CreateShaders();
for (int i = 0; i < Bodies.Count; i++)
{
MAstroBody m = Bodies[i];
//m.Radius = m.Radius * 0.5;
if (m.IsTemplate == true)
{
continue;
}
m.ListIndex = i;
Vector3d pos = m.Position + new Vector3d(-m.Radius.X, 0, 0) * (m.HasRings == true ? 3.0 : 1.1);
MServerZone zone = new MServerZone("MASTER_ASTRONOMER", m.Name, "Astronomical",
MassiveTools.ToVector3_Server(pos));
zone.Rotation = MassiveTools.ArrayFromQuaterniond(Quaterniond.Identity);
zone.Description = m.Description + " \nRadius:" + m.Radius;
MMessageBus.AddZone(this, zone);
//Extensions.LookAt(m.Position + m.Radius * 2, m.Position), m.Name));
MSceneObject mo;
//planet files contain uvs for mercator
if (m.HasAtmosphere)
{
CurrentNear = m;
mo = Helper.CreateModel(MScene.AstroRoot, m.Name, @"Models\planets\earth.3ds", Vector3d.Zero);
//mo = Helper.CreateSphere(MScene.AstroRoot, 3, "Planet");
//mo.transform.Scale = m.Radius * 1.00055;
mo.transform.Scale = m.Radius;
}
else
{
mo = Helper.CreateModel(MScene.AstroRoot, m.Name, @"Models\planets\planet_sphere2.3ds", Vector3d.Zero);
mo.transform.Scale = m.Radius;
}
if (m.HasRings)
{
MModel ring = Helper.CreateModel(MScene.Priority2, m.Name + "_rings", @"Models\planets\planet_rings.3ds", Vector3d.Zero);
ring.transform.Position = m.Position;
ring.transform.Rotation = Quaterniond.FromEulerAngles(0, 0, 5 * Math.PI / 180);
ring.transform.Scale = m.Radius;
ring.InstanceID = m.Name;
ring.TemplateID = m.Name;
ring.DistanceThreshold = m.Radius.X * 12;
ring.OwnerID = "MasterAstronomer";
MMaterial ringmat = new MMaterial(m.Name + "_mat");
ringmat.AddShader((MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER));
MTexture ringtex = Globals.TexturePool.GetTexture(@"Textures\Planets\saturn_rings.png");
ringmat.SetDiffuseTexture(ringtex);
ring.SetMaterial(ringmat);
MPhysicsObject ringpo = new MPhysicsObject(ring, "Physics", 0, MPhysicsObject.EShape.ConcaveMesh, false, m.Radius);
ringpo.SetLinearFactor(0, 0, 0);
ringpo.SetRestitution(0.5);
}
mo.transform.Position = m.Position;
//mo.transform.Scale = m.Radius * 1.9999;
mo.InstanceID = m.Name;
mo.TemplateID = m.Name;
mo.OwnerID = "MasterAstronomer";
mo.DistanceThreshold = m.Radius.X * 110002; //distance at which it becomes visible
//MModel mod = (MModel)mo.FindModuleByType(EType.Model);
//mod.DistanceThreshold = mo.DistanceThreshold;
//MMesh met = (MMesh)mod.FindModuleByType(EType.Mesh);
//if ( met != null ) {
//met.DistanceThreshold = mo.DistanceThreshold;
//}
mo.Tag = m;
m.Tag = mo;
//now that we have a 3d model, apply some progressive textures (will auto-switch with smooth transition in shader)
MMaterial mat = new MMaterial(m.Name + "_mat");
mat.AddShader((MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER));
MTexture tex = Globals.TexturePool.GetTexture(m.TextureName);
mat.SetDiffuseTexture(tex);
mo.SetMaterial(mat);
MTexture tex2 = Globals.TexturePool.GetTexture("Textures\\terrain\\sand01b.jpg");
mat.SetMultiTexture(tex2);
MTexture tex3 = Globals.TexturePool.GetTexture("Textures\\terrain\\water.jpg");
mat.SetNormalMap(tex3);
double dia = 2.0 * Math.PI * m.Radius.X * 0.0000001;
//double dia = 1;
mat.Tex2CoordScale = new Vector2((float)dia, (float)dia);
mo.SetMaterial(mat);
MScene.MaterialRoot.Add(mat);
if (m.HasAtmosphere)
{
if (Settings.DrawTerrains == true)
{
m.AddDynamicTerrain(); //adds tile based terrain (from e.g. tile service)
}
//MPhysicsObject po = new MPhysicsObject(mo, "Physics", 0, MPhysicsObject.EShape.ConcaveMesh,
//false, m.Radius);
MPhysicsObject po = new MPhysicsObject(mo, "Physics", 0, MPhysicsObject.EShape.Sphere,
false, m.Radius);
//po.SetLinearFactor(0, 0, 0);
//po.SetRestitution(0.5);
//MSphere moc = Helper.CreateSphere(MScene.AstroRoot, 3, m.Name+ "Clouds", Vector3d.Zero);
MModel moc = Helper.CreateModel(MScene.AstroRoot, m.Name + "_clouds", @"Models\planets\clouds.3ds", Vector3d.Zero);
moc.CastsShadow = false;
moc.transform.Position = m.Position;
moc.transform.Scale = m.Radius;
moc.DistanceThreshold = m.Radius.X * 3;
//moc.transform.Scale = m.Radius*2.1;
moc.InstanceID = m.Name;
moc.TemplateID = m.Name;
moc.OwnerID = "MasterAstronomer";
moc.Tag = m;
MMaterial cmat = new MMaterial("CloudMat");
cmat.AddShader((MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER));
cmat.Opacity = 1;
cmat.IsSky = 1;
// = new MTexture("CloudTex");
MTexture ctex = Globals.TexturePool.GetTexture(CloudTexURL);
ctex.Additive = false;
cmat.SetDiffuseTexture(ctex);
moc.SetMaterial(cmat);
MScene.MaterialRoot.Add(cmat);
MModel sky = Helper.CreateModel(MScene.AstroRoot, m.Name + "_sky", @"Models\sky.3ds", Vector3d.Zero);
sky.CastsShadow = false;
sky.transform.Position = m.Position;
sky.transform.Scale = m.Radius;
//moc.transform.Scale = m.Radius*2.1;
sky.InstanceID = m.Name;
sky.TemplateID = m.Name;
sky.OwnerID = "MasterAstronomer";
sky.Tag = m;
sky.SetMaterial(cmat);
sky.DistanceThreshold = m.Radius.X * 4;
MObjectAnimation ani = new MObjectAnimation();
ani.AngleOffset = Quaterniond.FromEulerAngles(0, 0.002, 0);
ani.Speed = 1;
sky.Add(ani);
sky.SetMaterial(MSkyMaterial);
/*MMaterial csky = new MMaterial("Skymat");
* csky.AddShader((MShader)MScene.MaterialRoot.FindModuleByName(MShader.DEFAULT_SHADER));
* csky.Opacity = 0.5;
* csky.IsSky = 1;
* // = new MTexture("CloudTex");
* MTexture cSkyTex = Globals.TexturePool.GetTexture(OpaqueCloudTexURL);
* cSkyTex.Additive = false;
* csky.SetDiffuseTexture(cSkyTex);
* sky.SetMaterial(csky);
* MScene.MaterialRoot.Add(csky);
*/
/* MSphere water = Helper.CreateSphere(MScene.ModelRoot, 5, "Water");
* water.transform.Position = m.Position;
* water.transform.Scale = m.Radius * 2.00;
* MMaterial waterman = new MMaterial("Watermat");
* MShader shader = new MShader("watershader");
* shader.Load("ocean_vs.glsl", "ocean_fs.glsl");
* shader.Bind();
* shader.SetInt("diffuseTexture", 0);
* shader.SetInt("shadowMap", 1);
* waterman.AddShader(shader);
* water.SetMaterial(waterman);
*/
//water.SetMaterial((MMaterial)MScene.MaterialRoot.FindModuleByName(MMaterial.DEFAULT_MATERIAL));
}
else
{
MPhysicsObject po = new MPhysicsObject(mo, "Physics", 0, MPhysicsObject.EShape.Sphere, false,
m.Radius * 0.999);
po.SetLinearFactor(0, 0, 0);
po.SetRestitution(0.5);
}
m.Setup();
//Console.WriteLine("Created:" + mo.Name + ":" + (mo.transform.Position) + " R:" + m.Radius);
}
}
private void MMessageBus_AvatarMovedEvent(object sender, MoveEvent e)
{
Globals.UserAccount.CurrentPosition = MassiveTools.ArrayFromVector(Globals.Avatar.GetPosition());
}
