corrade-vassal – Rev 1
?pathlinks?
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.IO;
using System.Runtime.InteropServices;
using Tao.OpenGl;
using Tao.Platform.Windows;
using ICSharpCode.SharpZipLib.Zip;
using OpenMetaverse;
using OpenMetaverse.StructuredData;
using OpenMetaverse.Imaging;
using OpenMetaverse.Rendering;
using OpenMetaverse.Assets;
namespace PrimWorkshop
{
public partial class frmBrowser : Form
{
const float DEG_TO_RAD = 0.0174532925f;
const uint TERRAIN_START = (uint)Int32.MaxValue + 1;
ContextMenu ExportPrimMenu;
ContextMenu ExportTerrainMenu;
GridClient Client;
Camera Camera;
Dictionary<uint, Primitive> RenderFoliageList = new Dictionary<uint, Primitive>();
Dictionary<uint, RenderablePrim> RenderPrimList = new Dictionary<uint, RenderablePrim>();
Dictionary<UUID, GlacialComponents.Controls.GLItem> DownloadList = new Dictionary<UUID, GlacialComponents.Controls.GLItem>();
EventHandler IdleEvent;
System.Timers.Timer ProgressTimer;
int TotalPrims;
// Textures
Dictionary<UUID, TextureInfo> Textures = new Dictionary<UUID, TextureInfo>();
// Terrain
float MaxHeight = 0.1f;
TerrainPatch[,] Heightmap;
HeightmapLookupValue[] LookupHeightTable;
// Picking globals
bool Clicked = false;
int ClickX = 0;
int ClickY = 0;
uint LastHit = 0;
//warning CS0414: The private field `PrimWorkshop.frmBrowser.PivotPosition' is assigned but its value is never used
Vector3 PivotPosition = Vector3.Zero;
private bool Pivoting;
Point LastPivot;
//
const int SELECT_BUFSIZE = 512;
uint[] SelectBuffer = new uint[SELECT_BUFSIZE];
//warning CS0414: The private field `PrimWorkshop.frmBrowser.msg' is assigned but its value is never used
NativeMethods.Message msg;
private bool AppStillIdle
{
get { return !NativeMethods.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0); }
}
/// <summary>
/// Default constructor
/// </summary>
public frmBrowser()
{
InitializeComponent();
// Setup OpenGL
glControl.InitializeContexts();
glControl.SwapBuffers();
glControl.MouseWheel += new MouseEventHandler(glControl_MouseWheel);
// Login server URLs
cboServer.Items.Add(Settings.AGNI_LOGIN_SERVER);
cboServer.Items.Add(Settings.ADITI_LOGIN_SERVER);
cboServer.Items.Add("http://osgrid.org:8002/");
cboServer.SelectedIndex = 0;
// Context menus
ExportPrimMenu = new ContextMenu();
ExportPrimMenu.MenuItems.Add("Download", new EventHandler(DownloadMenu_Clicked));
ExportPrimMenu.MenuItems.Add("Download All Objects", new EventHandler(DownloadAllMenu_Clicked));
ExportTerrainMenu = new ContextMenu();
ExportTerrainMenu.MenuItems.Add("Teleport", new EventHandler(TeleportMenu_Clicked));
ExportTerrainMenu.MenuItems.Add("Export Terrain", new EventHandler(ExportTerrainMenu_Clicked));
ExportTerrainMenu.MenuItems.Add("Import Object", new EventHandler(ImportObjectMenu_Clicked));
ExportTerrainMenu.MenuItems.Add("Import Sim", new EventHandler(ImportSimMenu_Clicked));
// Setup a timer for updating the progress bar
ProgressTimer = new System.Timers.Timer(250);
ProgressTimer.Elapsed +=
delegate(object sender, System.Timers.ElapsedEventArgs e)
{
UpdatePrimProgress();
};
ProgressTimer.Start();
IdleEvent = new EventHandler(Application_Idle);
Application.Idle += IdleEvent;
// Show a flat sim before login so the screen isn't so boring
InitHeightmap();
InitOpenGL();
InitCamera();
glControl_Resize(null, null);
}
private void InitLists()
{
TotalPrims = 0;
lock (Textures)
{
foreach (TextureInfo tex in Textures.Values)
{
int id = tex.ID;
Gl.glDeleteTextures(1, ref id);
}
Textures.Clear();
}
lock (RenderPrimList) RenderPrimList.Clear();
lock (RenderFoliageList) RenderFoliageList.Clear();
}
private void InitializeObjects()
{
InitLists();
if (DownloadList != null)
lock (DownloadList)
DownloadList.Clear();
// Initialize the SL client
Client = new GridClient();
Client.Settings.MULTIPLE_SIMS = false;
Client.Settings.ALWAYS_DECODE_OBJECTS = true;
Client.Settings.ALWAYS_REQUEST_OBJECTS = true;
Client.Settings.SEND_AGENT_UPDATES = true;
Client.Settings.USE_ASSET_CACHE = true;
//Client.Settings.ASSET_CACHE_DIR = Application.StartupPath + System.IO.Path.DirectorySeparatorChar + "cache";
Client.Settings.ALWAYS_REQUEST_PARCEL_ACL = false;
Client.Settings.ALWAYS_REQUEST_PARCEL_DWELL = false;
// Crank up the throttle on texture downloads
Client.Throttle.Texture = 446000.0f;
// FIXME: Write our own avatar tracker so we don't double store prims
Client.Settings.OBJECT_TRACKING = false; // We use our own object tracking system
Client.Settings.AVATAR_TRACKING = true; //but we want to use the libsl avatar system
Client.Network.LoginProgress += Network_OnLogin;
Client.Network.Disconnected += Network_OnDisconnected;
Client.Network.SimChanged += Network_OnCurrentSimChanged;
Client.Network.EventQueueRunning += Network_OnEventQueueRunning;
Client.Objects.ObjectUpdate += Objects_OnNewPrim;
Client.Terrain.LandPatchReceived += new EventHandler<LandPatchReceivedEventArgs>(Terrain_LandPatchReceived);
Client.Parcels.SimParcelsDownloaded += new EventHandler<SimParcelsDownloadedEventArgs>(Parcels_SimParcelsDownloaded);
Client.Assets.ImageReceiveProgress += new EventHandler<ImageReceiveProgressEventArgs>(Assets_ImageReceiveProgress);
// Initialize the camera object
InitCamera();
// Setup the libsl camera to match our Camera struct
UpdateCamera();
glControl_Resize(null, null);
/*
// Enable lighting
Gl.glEnable(Gl.GL_LIGHTING);
Gl.glEnable(Gl.GL_LIGHT0);
float[] lightPosition = { 128.0f, 64.0f, 96.0f, 0.0f };
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, lightPosition);
// Setup ambient property
float[] ambientLight = { 0.2f, 0.2f, 0.2f, 0.0f };
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambientLight);
// Setup specular property
float[] specularLight = { 0.5f, 0.5f, 0.5f, 0.0f };
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPECULAR, specularLight);
*/
}
void Objects_NewPrim(object sender, PrimEventArgs e)
{
throw new NotImplementedException();
}
void Parcels_SimParcelsDownloaded(object sender, SimParcelsDownloadedEventArgs e)
{
TotalPrims = 0;
e.Parcels.ForEach(
delegate(Parcel parcel)
{
TotalPrims += parcel.TotalPrims;
});
UpdatePrimProgress(); TotalPrims = 0;
e.Parcels.ForEach(
delegate(Parcel parcel)
{
TotalPrims += parcel.TotalPrims;
});
UpdatePrimProgress();
}
private void InitOpenGL()
{
Gl.glShadeModel(Gl.GL_SMOOTH);
Gl.glClearDepth(1.0f);
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glDepthMask(Gl.GL_TRUE);
Gl.glDepthFunc(Gl.GL_LEQUAL);
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
}
private void InitHeightmap()
{
// Initialize the heightmap
Heightmap = new TerrainPatch[16, 16];
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 16; x++)
{
Heightmap[y, x] = new TerrainPatch();
Heightmap[y, x].Data = new float[16 * 16];
}
}
// Speed up terrain exports with a lookup table
LookupHeightTable = new HeightmapLookupValue[256 * 256];
for (int i = 0; i < 256; i++)
{
for (int j = 0; j < 256; j++)
{
LookupHeightTable[i + (j * 256)] = new HeightmapLookupValue((ushort)(i + (j * 256)), ((float)i * ((float)j / 127.0f)));
}
}
Array.Sort<HeightmapLookupValue>(LookupHeightTable);
}
private void InitCamera()
{
Camera = new Camera();
Camera.Position = new Vector3(128f, -192f, 90f);
Camera.FocalPoint = new Vector3(128f, 128f, 0f);
Camera.Zoom = 1.0d;
Camera.Far = 512.0d;
}
private void UpdatePrimProgress()
{
if (this.InvokeRequired)
{
BeginInvoke((MethodInvoker)delegate() { UpdatePrimProgress(); });
}
else
{
try
{
if (RenderPrimList != null && RenderFoliageList != null)
{
int count = RenderPrimList.Count + RenderFoliageList.Count;
lblPrims.Text = String.Format("Prims: {0} / {1}", count, TotalPrims);
progPrims.Maximum = (TotalPrims > count) ? TotalPrims : count;
progPrims.Value = count;
}
else
{
lblPrims.Text = String.Format("Prims: 0 / {0}", TotalPrims);
progPrims.Maximum = TotalPrims;
progPrims.Value = 0;
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
private void UpdateCamera()
{
if (Client != null)
{
Client.Self.Movement.Camera.LookAt(Camera.Position, Camera.FocalPoint);
Client.Self.Movement.Camera.Far = (float)Camera.Far;
}
Gl.glPushMatrix();
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
SetPerspective();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glPopMatrix();
}
private bool ExportObject(RenderablePrim parent, string fileName, out int prims, out int textures, out string error)
{
// Build a list of primitives (parent+children) to export
List<Primitive> primList = new List<Primitive>();
primList.Add(parent.Prim);
lock (RenderPrimList)
{
foreach (RenderablePrim render in RenderPrimList.Values)
{
if (render.Prim.ParentID == parent.Prim.LocalID)
primList.Add(render.Prim);
}
}
return ExportObjects(primList, fileName, out prims, out textures, out error);
}
private bool ExportSim(string fileName, out int prims, out int textures, out string error)
{
// Add all of the prims in this sim to the export list
List<Primitive> primList = new List<Primitive>();
lock (RenderPrimList)
{
foreach (RenderablePrim render in RenderPrimList.Values)
{
primList.Add(render.Prim);
}
}
return ExportObjects(primList, fileName, out prims, out textures, out error);
}
private bool ExportObjects(List<Primitive> primList, string fileName, out int prims, out int textures, out string error)
{
List<UUID> textureList = new List<UUID>();
prims = 0;
textures = 0;
// Write the LLSD to the hard drive in XML format
string output = OSDParser.SerializeLLSDXmlString(Helpers.PrimListToOSD(primList));
try
{
// Create a temporary directory
string tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
Directory.CreateDirectory(tempPath);
// Write the prim XML file
File.WriteAllText(System.IO.Path.Combine(tempPath, "prims.xml"), output);
prims = primList.Count;
// Build a list of all the referenced textures in this prim list
foreach (Primitive prim in primList)
{
for (int i = 0; i < prim.Textures.FaceTextures.Length; i++)
{
Primitive.TextureEntryFace face = prim.Textures.FaceTextures[i];
if (face != null && face.TextureID != UUID.Zero && face.TextureID != Primitive.TextureEntry.WHITE_TEXTURE)
{
if (!textureList.Contains(face.TextureID))
textureList.Add(face.TextureID);
}
}
}
// Copy all of relevant textures from the cache to the temp directory
foreach (UUID texture in textureList)
{
string tempFileName = Client.Assets.Cache.AssetFileName(texture);
if (!String.IsNullOrEmpty(tempFileName))
{
File.Copy(tempFileName, System.IO.Path.Combine(tempPath, texture.ToString() + ".jp2"));
++textures;
}
else
{
Console.WriteLine("Missing texture file during download: " + texture.ToString());
}
}
// Zip up the directory
string[] filenames = Directory.GetFiles(tempPath);
using (ZipOutputStream s = new ZipOutputStream(File.Create(fileName)))
{
s.SetLevel(9);
byte[] buffer = new byte[4096];
foreach (string file in filenames)
{
ZipEntry entry = new ZipEntry(System.IO.Path.GetFileName(file));
entry.DateTime = DateTime.Now;
s.PutNextEntry(entry);
using (FileStream fs = File.OpenRead(file))
{
int sourceBytes;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
s.Write(buffer, 0, sourceBytes);
} while (sourceBytes > 0);
}
}
s.Finish();
s.Close();
}
error = null;
return true;
}
catch (Exception ex)
{
error = ex.Message;
return false;
}
}
private List<Primitive> ImportObjects(string fileName, out string tempPath, out string error)
{
tempPath = null;
error = null;
string primFile = null;
try
{
// Create a temporary directory
tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
Directory.CreateDirectory(tempPath);
// Unzip the primpackage
using (ZipInputStream s = new ZipInputStream(File.OpenRead(fileName)))
{
ZipEntry theEntry;
// Loop through and confirm there is a prims.xml file
while ((theEntry = s.GetNextEntry()) != null)
{
if (String.Equals("prims.xml", theEntry.Name.ToLower()))
{
primFile = theEntry.Name;
break;
}
}
if (primFile != null)
{
// Prepend the path to the primFile (that will be created in the next loop)
primFile = System.IO.Path.Combine(tempPath, primFile);
}
else
{
// Didn't find a prims.xml file, bail out
error = "No prims.xml file found in the archive";
return null;
}
// Reset to the beginning of the zip file
s.Seek(0, SeekOrigin.Begin);
Logger.DebugLog("Unpacking archive to " + tempPath);
// Unzip all of the texture and xml files
while ((theEntry = s.GetNextEntry()) != null)
{
string directory = System.IO.Path.GetDirectoryName(theEntry.Name);
string file = System.IO.Path.GetFileName(theEntry.Name);
// Skip directories
if (directory.Length > 0)
continue;
if (!String.IsNullOrEmpty(file))
{
string filelow = file.ToLower();
if (filelow.EndsWith(".jp2") || filelow.EndsWith(".tga") || filelow.EndsWith(".xml"))
{
Logger.DebugLog("Unpacking " + file);
// Create the full path from the temp path and new filename
string filePath = System.IO.Path.Combine(tempPath, file);
using (FileStream streamWriter = File.Create(filePath))
{
const int READ_BUFFER_SIZE = 2048;
int size = READ_BUFFER_SIZE;
byte[] data = new byte[READ_BUFFER_SIZE];
while (true)
{
size = s.Read(data, 0, data.Length);
if (size > 0)
streamWriter.Write(data, 0, size);
else
break;
}
}
}
else
{
Logger.Log("Skipping file " + file, Helpers.LogLevel.Info);
}
}
}
}
// Decode the .prims file
string raw = File.ReadAllText(primFile);
OSD osd = OSDParser.DeserializeLLSDXml(raw);
return Helpers.OSDToPrimList(osd);
}
catch (Exception e)
{
error = e.Message;
return null;
}
}
private void DownloadMenu_Clicked(object sender, EventArgs e)
{
// Confirm that there actually is a selected object
RenderablePrim parent;
if (RenderPrimList.TryGetValue(LastHit, out parent))
{
if (parent.Prim.ParentID == 0)
{
// Valid parent prim is selected, throw up the save file dialog
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Prim Package (*.zip)|*.zip";
if (dialog.ShowDialog() == DialogResult.OK)
{
string error;
int prims, textures;
if (ExportObject(parent, dialog.FileName, out prims, out textures, out error))
MessageBox.Show(String.Format("Exported {0} prims and {1} textures", prims, textures));
else
MessageBox.Show("Export failed: " + error);
}
}
else
{
// This should have already been fixed in the picking processing code
Console.WriteLine("Download menu clicked when a child prim is selected!");
glControl.ContextMenu = null;
LastHit = 0;
}
}
else
{
Console.WriteLine("Download menu clicked when there is no selected prim!");
glControl.ContextMenu = null;
LastHit = 0;
}
}
private void DownloadAllMenu_Clicked(object sender, EventArgs e)
{
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Prim Package (*.zip)|*.zip";
if (dialog.ShowDialog() == DialogResult.OK)
{
string error;
int prims, textures;
if (ExportSim(dialog.FileName, out prims, out textures, out error))
MessageBox.Show(String.Format("Exported {0} prims and {1} textures", prims, textures));
else
MessageBox.Show("Export failed: " + error);
}
}
private void ExportTerrainMenu_Clicked(object sender, EventArgs e)
{
// Valid parent prim is selected, throw up the save file dialog
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Terrain RAW (*.raw)|*.raw";
if (dialog.ShowDialog() == DialogResult.OK)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object obj, DoWorkEventArgs args)
{
byte red, green, blue, alpha1, alpha2, alpha3, alpha4, alpha5, alpha6, alpha7, alpha8, alpha9, alpha10;
try
{
FileInfo file = new FileInfo(dialog.FileName);
FileStream s = file.Open(FileMode.OpenOrCreate, FileAccess.Write);
BinaryWriter binStream = new BinaryWriter(s);
for (int y = 0; y < 256; y++)
{
for (int x = 0; x < 256; x++)
{
int xBlock = x / 16;
int yBlock = y / 16;
int xOff = x - (xBlock * 16);
int yOff = y - (yBlock * 16);
float t = Heightmap[yBlock, xBlock].Data[yOff * 16 + xOff];
//float min = Single.MaxValue;
int index = 0;
// The lookup table is pre-sorted, so we either find an exact match or
// the next closest (smaller) match with a binary search
index = Array.BinarySearch<HeightmapLookupValue>(LookupHeightTable, new HeightmapLookupValue(0, t));
if (index < 0)
index = ~index - 1;
index = LookupHeightTable[index].Index;
/*for (int i = 0; i < 65536; i++)
{
if (Math.Abs(t - LookupHeightTable[i].Value) < min)
{
min = Math.Abs(t - LookupHeightTable[i].Value);
index = i;
}
}*/
red = (byte)(index & 0xFF);
green = (byte)((index >> 8) & 0xFF);
blue = 20;
alpha1 = 0; // Land Parcels
alpha2 = 0; // For Sale Land
alpha3 = 0; // Public Edit Object
alpha4 = 0; // Public Edit Land
alpha5 = 255; // Safe Land
alpha6 = 255; // Flying Allowed
alpha7 = 255; // Create Landmark
alpha8 = 255; // Outside Scripts
alpha9 = red;
alpha10 = green;
binStream.Write(red);
binStream.Write(green);
binStream.Write(blue);
binStream.Write(alpha1);
binStream.Write(alpha2);
binStream.Write(alpha3);
binStream.Write(alpha4);
binStream.Write(alpha5);
binStream.Write(alpha6);
binStream.Write(alpha7);
binStream.Write(alpha8);
binStream.Write(alpha9);
binStream.Write(alpha10);
}
}
binStream.Close();
s.Close();
BeginInvoke((MethodInvoker)delegate() { System.Windows.Forms.MessageBox.Show("Exported heightmap"); });
}
catch (Exception ex)
{
BeginInvoke((MethodInvoker)delegate() { System.Windows.Forms.MessageBox.Show("Error exporting heightmap: " + ex.Message); });
}
};
worker.RunWorkerAsync();
}
}
private void TeleportMenu_Clicked(object sender, EventArgs e)
{
if (Client != null && Client.Network.CurrentSim != null)
{
if (LastHit >= TERRAIN_START)
{
// Determine which piece of terrain was clicked on
int y = (int)(LastHit - TERRAIN_START) / 16;
int x = (int)(LastHit - (TERRAIN_START + (y * 16)));
Vector3 targetPos = new Vector3(x * 16 + 8, y * 16 + 8, 0f);
Console.WriteLine("Starting local teleport to " + targetPos.ToString());
Client.Self.RequestTeleport(Client.Network.CurrentSim.Handle, targetPos);
}
else
{
// This shouldn't have happened...
glControl.ContextMenu = null;
}
}
}
private void ImportObjectMenu_Clicked(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Prim Package (*.zip,*.primpackage)|*.zip;*.primpackage";
if (dialog.ShowDialog() == DialogResult.OK)
{
// FIXME: Disable any further imports or exports until this is finished
// Import the prims
string error, texturePath;
List<Primitive> primList = ImportObjects(dialog.FileName, out texturePath, out error);
if (primList != null)
{
// Determine the total height of the object
float minHeight = Single.MaxValue;
float maxHeight = Single.MinValue;
//float totalHeight = 0f;
for (int i = 0; i < primList.Count; i++)
{
Primitive prim = primList[i];
// Find the largest scale dimension (quick cheat to avoid figuring in the rotation)
float scale = prim.Scale.X;
if (prim.Scale.Y > scale) scale = prim.Scale.Y;
if (prim.Scale.Z > scale) scale = prim.Scale.Z;
float top = prim.Position.Z + (scale * 0.5f);
float bottom = top - scale;
if (top > maxHeight) maxHeight = top;
if (bottom < minHeight) minHeight = bottom;
}
//totalHeight = maxHeight - minHeight;
// Create a progress bar for the import process
ProgressBar prog = new ProgressBar();
prog.Minimum = 0;
prog.Maximum = primList.Count;
prog.Value = 0;
// List item
GlacialComponents.Controls.GLItem item = new GlacialComponents.Controls.GLItem();
item.SubItems[0].Text = "Import process";
item.SubItems[1].Control = prog;
lstDownloads.Items.Add(item);
lstDownloads.Invalidate();
// Start the import process in the background
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object s, DoWorkEventArgs ea)
{
// Set the spot choosing state
// Wait for a spot to be chosen
// mouse2dto3d()
// Add (0, 0, totalHeight * 0.5f) to the clicked position
for (int i = 0; i < primList.Count; i++)
{
Primitive prim = primList[i];
for (int j = 0; j < prim.Textures.FaceTextures.Length; j++)
{
// Check if this texture exists
// If not, wait while it uploads
}
// Create this prim (using weird SL math to get the correct position)
// Wait for the callback to fire for this prim being created
// Add this prim's localID to a list
// Set any additional properties. If this is the root prim, do not apply rotation
// Update the progress bar
BeginInvoke((MethodInvoker)delegate() { prog.Value = i; });
}
// Link all of the prims together
// Apply root prim rotation
};
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs ea)
{
BeginInvoke(
(MethodInvoker)delegate()
{
lstDownloads.Items.Remove(item);
lstDownloads.Invalidate();
});
};
worker.RunWorkerAsync();
}
else
{
// FIXME: Re-enable imports and exports
MessageBox.Show(error);
return;
}
}
}
private void ImportSimMenu_Clicked(object sender, EventArgs e)
{
}
private void SetPerspective()
{
Glu.gluPerspective(50.0d * Camera.Zoom, 1.0d, 0.1d, Camera.Far);
}
private void StartPicking(int cursorX, int cursorY)
{
int[] viewport = new int[4];
Gl.glSelectBuffer(SELECT_BUFSIZE, SelectBuffer);
Gl.glRenderMode(Gl.GL_SELECT);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPushMatrix();
Gl.glLoadIdentity();
Gl.glGetIntegerv(Gl.GL_VIEWPORT, viewport);
Glu.gluPickMatrix(cursorX, viewport[3] - cursorY, 5, 5, viewport);
SetPerspective();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glInitNames();
}
private void StopPicking()
{
int hits;
// Resotre the original projection matrix
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPopMatrix();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glFlush();
// Return to normal rendering mode
hits = Gl.glRenderMode(Gl.GL_RENDER);
// If there are hits process them
if (hits != 0)
{
ProcessHits(hits, SelectBuffer);
}
else
{
LastHit = 0;
glControl.ContextMenu = null;
}
}
private void ProcessHits(int hits, uint[] selectBuffer)
{
uint names = 0;
uint numNames = 0;
uint minZ = 0xffffffff;
uint ptr = 0;
uint ptrNames = 0;
for (uint i = 0; i < hits; i++)
{
names = selectBuffer[ptr];
++ptr;
if (selectBuffer[ptr] < minZ)
{
numNames = names;
minZ = selectBuffer[ptr];
ptrNames = ptr + 2;
}
ptr += names + 2;
}
ptr = ptrNames;
for (uint i = 0; i < numNames; i++, ptr++)
{
LastHit = selectBuffer[ptr];
}
if (LastHit >= TERRAIN_START)
{
// Terrain was clicked on, turn off the context menu
glControl.ContextMenu = ExportTerrainMenu;
}
else
{
RenderablePrim render;
if (RenderPrimList.TryGetValue(LastHit, out render))
{
if (render.Prim.ParentID == 0)
{
Camera.FocalPoint = render.Prim.Position;
UpdateCamera();
}
else
{
// See if we have the parent
RenderablePrim renderParent;
if (RenderPrimList.TryGetValue(render.Prim.ParentID, out renderParent))
{
// Turn on the context menu
glControl.ContextMenu = ExportPrimMenu;
// Change the clicked on prim to the parent. Camera position stays on the
// clicked child but the highlighting is applied to all the children
LastHit = renderParent.Prim.LocalID;
Camera.FocalPoint = renderParent.Prim.Position + render.Prim.Position;
UpdateCamera();
}
else
{
Console.WriteLine("Clicked on a child prim with no parent!");
LastHit = 0;
}
}
}
}
}
private void Objects_OnNewPrim(object sender, PrimEventArgs e)
{
Primitive prim = e.Prim;
if (prim.PrimData.PCode == PCode.Grass || prim.PrimData.PCode == PCode.Tree || prim.PrimData.PCode == PCode.NewTree)
{
lock (RenderFoliageList)
RenderFoliageList[prim.LocalID] = prim;
return;
}
RenderablePrim render = new RenderablePrim();
render.Prim = prim;
// FIXME: Handle sculpted prims by calling Render.Plugin.GenerateFacetedSculptMesh() instead
render.Mesh = Render.Plugin.GenerateFacetedMesh(prim, DetailLevel.High);
// Create a FaceData struct for each face that stores the 3D data
// in a Tao.OpenGL friendly format
for (int j = 0; j < render.Mesh.Faces.Count; j++)
{
Face face = render.Mesh.Faces[j];
FaceData data = new FaceData();
// Vertices for this face
data.Vertices = new float[face.Vertices.Count * 3];
for (int k = 0; k < face.Vertices.Count; k++)
{
data.Vertices[k * 3 + 0] = face.Vertices[k].Position.X;
data.Vertices[k * 3 + 1] = face.Vertices[k].Position.Y;
data.Vertices[k * 3 + 2] = face.Vertices[k].Position.Z;
}
// Indices for this face
data.Indices = face.Indices.ToArray();
// Texture transform for this face
Primitive.TextureEntryFace teFace = prim.Textures.GetFace((uint)j);
Render.Plugin.TransformTexCoords(face.Vertices, face.Center, teFace, prim.Scale);
// Texcoords for this face
data.TexCoords = new float[face.Vertices.Count * 2];
for (int k = 0; k < face.Vertices.Count; k++)
{
data.TexCoords[k * 2 + 0] = face.Vertices[k].TexCoord.X;
data.TexCoords[k * 2 + 1] = face.Vertices[k].TexCoord.Y;
}
// Texture for this face
if (teFace.TextureID != UUID.Zero &&
teFace.TextureID != Primitive.TextureEntry.WHITE_TEXTURE)
{
lock (Textures)
{
if (!Textures.ContainsKey(teFace.TextureID))
{
// We haven't constructed this image in OpenGL yet, get ahold of it
Client.Assets.RequestImage(teFace.TextureID, ImageType.Normal, TextureDownloader_OnDownloadFinished);
}
}
}
// Set the UserData for this face to our FaceData struct
face.UserData = data;
render.Mesh.Faces[j] = face;
}
lock (RenderPrimList) RenderPrimList[prim.LocalID] = render;
}
private void Terrain_LandPatchReceived(object sender, LandPatchReceivedEventArgs e)
{
if (Client != null && Client.Network.CurrentSim == e.Simulator)
{
Heightmap[e.Y, e.X].Data = e.HeightMap;
}
// Find the new max height
for (int i = 0; i < e.HeightMap.Length; i++)
{
if (e.HeightMap[i] > MaxHeight)
MaxHeight = e.HeightMap[i];
}
}
private void Network_OnLogin(object sender, LoginProgressEventArgs e)
{
if (e.Status == LoginStatus.Success)
{
// Success!
}
else if (e.Status == LoginStatus.Failed)
{
BeginInvoke(
(MethodInvoker)delegate()
{
MessageBox.Show(this, String.Format("Error logging in ({0}): {1}",
Client.Network.LoginErrorKey, Client.Network.LoginMessage));
cmdLogin.Text = "Login";
txtFirst.Enabled = txtLast.Enabled = txtPass.Enabled = true;
});
}
}
private void Network_OnDisconnected(object sender, DisconnectedEventArgs e)
{
BeginInvoke(
(MethodInvoker)delegate()
{
cmdTeleport.Enabled = false;
DoLogout();
});
}
private void Network_OnCurrentSimChanged(object sender, SimChangedEventArgs e)
{
Console.WriteLine("CurrentSim set to " + Client.Network.CurrentSim + ", downloading parcel information");
BeginInvoke((MethodInvoker)delegate() { txtSim.Text = Client.Network.CurrentSim.Name; });
//InitHeightmap();
InitLists();
// Disable teleports until the new event queue comes online
if (!Client.Network.CurrentSim.Caps.IsEventQueueRunning)
BeginInvoke((MethodInvoker)delegate() { cmdTeleport.Enabled = false; });
}
private void Network_OnEventQueueRunning(object sender, EventQueueRunningEventArgs e)
{
if (e.Simulator == Client.Network.CurrentSim)
BeginInvoke((MethodInvoker)delegate() { cmdTeleport.Enabled = true; });
// Now seems like a good time to start requesting parcel information
Client.Parcels.RequestAllSimParcels(Client.Network.CurrentSim, false, 100);
}
private void RenderScene()
{
try
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glLoadIdentity();
Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
if (Clicked)
StartPicking(ClickX, ClickY);
// Setup wireframe or solid fill drawing mode
Gl.glPolygonMode(Gl.GL_FRONT, Gl.GL_LINE);
// Position the camera
Glu.gluLookAt(
Camera.Position.X, Camera.Position.Y, Camera.Position.Z,
Camera.FocalPoint.X, Camera.FocalPoint.Y, Camera.FocalPoint.Z,
0f, 0f, 1f);
RenderSkybox();
// Push the world matrix
Gl.glPushMatrix();
RenderTerrain();
RenderPrims();
RenderAvatars();
Gl.glDisableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
Gl.glDisableClientState(Gl.GL_VERTEX_ARRAY);
if (Clicked)
{
Clicked = false;
StopPicking();
}
// Pop the world matrix
Gl.glPopMatrix();
Gl.glFlush();
glControl.Invalidate();
}
catch (Exception)
{
}
}
static readonly Vector3[] SkyboxVerts = new Vector3[]
{
// Right side
new Vector3( 10.0f, 10.0f, -10.0f ), //Top left
new Vector3( 10.0f, 10.0f, 10.0f ), //Top right
new Vector3( 10.0f, -10.0f, 10.0f ), //Bottom right
new Vector3( 10.0f, -10.0f, -10.0f ), //Bottom left
// Left side
new Vector3( -10.0f, 10.0f, 10.0f ), //Top left
new Vector3( -10.0f, 10.0f, -10.0f ), //Top right
new Vector3( -10.0f, -10.0f, -10.0f ), //Bottom right
new Vector3( -10.0f, -10.0f, 10.0f ), //Bottom left
// Top side
new Vector3( -10.0f, 10.0f, 10.0f ), //Top left
new Vector3( 10.0f, 10.0f, 10.0f ), //Top right
new Vector3( 10.0f, 10.0f, -10.0f ), //Bottom right
new Vector3( -10.0f, 10.0f, -10.0f ), //Bottom left
// Bottom side
new Vector3( -10.0f, -10.0f, -10.0f ), //Top left
new Vector3( 10.0f, -10.0f, -10.0f ), //Top right
new Vector3( 10.0f, -10.0f, 10.0f ), //Bottom right
new Vector3( -10.0f, -10.0f, 10.0f ), //Bottom left
// Front side
new Vector3( -10.0f, 10.0f, -10.0f ), //Top left
new Vector3( 10.0f, 10.0f, -10.0f ), //Top right
new Vector3( 10.0f, -10.0f, -10.0f ), //Bottom right
new Vector3( -10.0f, -10.0f, -10.0f ), //Bottom left
// Back side
new Vector3( 10.0f, 10.0f, 10.0f ), //Top left
new Vector3( -10.0f, 10.0f, 10.0f ), //Top right
new Vector3( -10.0f, -10.0f, 10.0f ), //Bottom right
new Vector3( 10.0f, -10.0f, 10.0f ), //Bottom left
};
private void RenderSkybox()
{
//Gl.glTranslatef(0f, 0f, 0f);
}
private void RenderTerrain()
{
if (Heightmap != null)
{
int i = 0;
// No texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
for (int hy = 0; hy < 16; hy++)
{
for (int hx = 0; hx < 16; hx++)
{
uint patchName = (uint)(TERRAIN_START + i);
Gl.glPushName(patchName);
++i;
// Check if this patch is currently selected
bool selected = (LastHit == patchName);
for (int y = 0; y < 15; y++)
{
Gl.glBegin(Gl.GL_TRIANGLE_STRIP);
for (int x = 0; x < 15; x++)
{
// Vertex 0
float height = Heightmap[hy, hx].Data[y * 16 + x];
float color = height / MaxHeight;
float red = (selected) ? 1f : color;
Gl.glColor3f(red, color, color);
Gl.glTexCoord2f(0f, 0f);
Gl.glVertex3f(hx * 16 + x, hy * 16 + y, height);
// Vertex 1
height = Heightmap[hy, hx].Data[y * 16 + (x + 1)];
color = height / MaxHeight;
red = (selected) ? 1f : color;
Gl.glColor3f(red, color, color);
Gl.glTexCoord2f(1f, 0f);
Gl.glVertex3f(hx * 16 + x + 1, hy * 16 + y, height);
// Vertex 2
height = Heightmap[hy, hx].Data[(y + 1) * 16 + x];
color = height / MaxHeight;
red = (selected) ? 1f : color;
Gl.glColor3f(red, color, color);
Gl.glTexCoord2f(0f, 1f);
Gl.glVertex3f(hx * 16 + x, hy * 16 + y + 1, height);
// Vertex 3
height = Heightmap[hy, hx].Data[(y + 1) * 16 + (x + 1)];
color = height / MaxHeight;
red = (selected) ? 1f : color;
Gl.glColor3f(red, color, color);
Gl.glTexCoord2f(1f, 1f);
Gl.glVertex3f(hx * 16 + x + 1, hy * 16 + y + 1, height);
}
Gl.glEnd();
}
Gl.glPopName();
}
}
}
}
//int[] CubeMapDefines = new int[]
//{
// Gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
// Gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
// Gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
// Gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
// Gl.GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
// Gl.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
//};
private void RenderPrims()
{
if (RenderPrimList != null && RenderPrimList.Count > 0)
{
Gl.glEnable(Gl.GL_TEXTURE_2D);
lock (RenderPrimList)
{
bool firstPass = true;
Gl.glDisable(Gl.GL_BLEND);
Gl.glEnable(Gl.GL_DEPTH_TEST);
StartRender:
foreach (RenderablePrim render in RenderPrimList.Values)
{
RenderablePrim parentRender = RenderablePrim.Empty;
Primitive prim = render.Prim;
if (prim.ParentID != 0)
{
// Get the parent reference
if (!RenderPrimList.TryGetValue(prim.ParentID, out parentRender))
{
// Can't render a child with no parent prim, skip it
continue;
}
}
Gl.glPushName(prim.LocalID);
Gl.glPushMatrix();
if (prim.ParentID != 0)
{
// Child prim
Primitive parent = parentRender.Prim;
// Apply parent translation and rotation
Gl.glMultMatrixf(Math3D.CreateTranslationMatrix(parent.Position));
Gl.glMultMatrixf(Math3D.CreateRotationMatrix(parent.Rotation));
}
// Apply prim translation and rotation
Gl.glMultMatrixf(Math3D.CreateTranslationMatrix(prim.Position));
Gl.glMultMatrixf(Math3D.CreateRotationMatrix(prim.Rotation));
// Scale the prim
Gl.glScalef(prim.Scale.X, prim.Scale.Y, prim.Scale.Z);
// Draw the prim faces
for (int j = 0; j < render.Mesh.Faces.Count; j++)
{
Face face = render.Mesh.Faces[j];
FaceData data = (FaceData)face.UserData;
Color4 color = face.TextureFace.RGBA;
bool alpha = false;
int textureID = 0;
if (color.A < 1.0f)
alpha = true;
#region Texturing
TextureInfo info;
if (Textures.TryGetValue(face.TextureFace.TextureID, out info))
{
if (info.Alpha)
alpha = true;
textureID = info.ID;
// Enable texturing for this face
Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_FILL);
}
else
{
if (face.TextureFace.TextureID == Primitive.TextureEntry.WHITE_TEXTURE ||
face.TextureFace.TextureID == UUID.Zero)
{
Gl.glPolygonMode(Gl.GL_FRONT, Gl.GL_FILL);
}
else
{
Gl.glPolygonMode(Gl.GL_FRONT, Gl.GL_LINE);
}
}
if (firstPass && !alpha || !firstPass && alpha)
{
// Color this prim differently based on whether it is selected or not
if (LastHit == prim.LocalID || (LastHit != 0 && LastHit == prim.ParentID))
{
Gl.glColor4f(1f, color.G * 0.3f, color.B * 0.3f, color.A);
}
else
{
Gl.glColor4f(color.R, color.G, color.B, color.A);
}
// Bind the texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureID);
Gl.glTexCoordPointer(2, Gl.GL_FLOAT, 0, data.TexCoords);
Gl.glVertexPointer(3, Gl.GL_FLOAT, 0, data.Vertices);
Gl.glDrawElements(Gl.GL_TRIANGLES, data.Indices.Length, Gl.GL_UNSIGNED_SHORT, data.Indices);
}
#endregion Texturing
}
Gl.glPopMatrix();
Gl.glPopName();
}
if (firstPass)
{
firstPass = false;
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
//Gl.glDisable(Gl.GL_DEPTH_TEST);
goto StartRender;
}
}
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glDisable(Gl.GL_TEXTURE_2D);
}
}
private void RenderAvatars()
{
if (Client != null && Client.Network.CurrentSim != null)
{
Gl.glColor3f(0f, 1f, 0f);
Client.Network.CurrentSim.ObjectsAvatars.ForEach(
delegate(Avatar avatar)
{
Gl.glPushMatrix();
Gl.glTranslatef(avatar.Position.X, avatar.Position.Y, avatar.Position.Z);
Glu.GLUquadric quad = Glu.gluNewQuadric();
Glu.gluSphere(quad, 1.0d, 10, 10);
Glu.gluDeleteQuadric(quad);
Gl.glPopMatrix();
}
);
Gl.glColor3f(1f, 1f, 1f);
}
}
#region Texture Downloading
private void TextureDownloader_OnDownloadFinished(TextureRequestState state, AssetTexture asset)
{
bool alpha = false;
ManagedImage imgData = null;
byte[] raw = null;
bool success = (state == TextureRequestState.Finished);
UUID id = asset.AssetID;
try
{
// Load the image off the disk
if (success)
{
//ImageDownload download = TextureDownloader.GetTextureToRender(id);
if (OpenJPEG.DecodeToImage(asset.AssetData, out imgData))
{
raw = imgData.ExportRaw();
if ((imgData.Channels & ManagedImage.ImageChannels.Alpha) != 0)
alpha = true;
}
else
{
success = false;
Console.WriteLine("Failed to decode texture");
}
}
// Make sure the OpenGL commands run on the main thread
BeginInvoke(
(MethodInvoker)delegate()
{
if (success)
{
int textureID = 0;
try
{
Gl.glGenTextures(1, out textureID);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureID);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST); //Gl.GL_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_GENERATE_MIPMAP, Gl.GL_TRUE); //Gl.GL_FALSE);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA, bitmap.Width, bitmap.Height, 0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE,
// bitmapData.Scan0);
//int error = Gl.glGetError();
int error = Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA, imgData.Width, imgData.Height, Gl.GL_BGRA,
Gl.GL_UNSIGNED_BYTE, raw);
if (error == 0)
{
Textures[id] = new TextureInfo(textureID, alpha);
Console.WriteLine("Created OpenGL texture for " + id.ToString());
}
else
{
Textures[id] = new TextureInfo(0, false);
Console.WriteLine("Error creating OpenGL texture: " + error);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
// Remove this image from the download listbox
lock (DownloadList)
{
GlacialComponents.Controls.GLItem item;
if (DownloadList.TryGetValue(id, out item))
{
DownloadList.Remove(id);
try { lstDownloads.Items.Remove(item); }
catch (Exception) { }
lstDownloads.Invalidate();
}
}
});
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void Assets_ImageReceiveProgress(object sender, ImageReceiveProgressEventArgs e)
{
lock (DownloadList)
{
GlacialComponents.Controls.GLItem item;
if (DownloadList.TryGetValue(e.ImageID, out item))
{
// Update an existing item
BeginInvoke(
(MethodInvoker)delegate()
{
ProgressBar prog = (ProgressBar)item.SubItems[1].Control;
if (e.Total >= e.Received)
prog.Value = (int)Math.Round((((double)e.Received / (double)e.Total) * 100.0d));
});
}
else
{
// Progress bar
ProgressBar prog = new ProgressBar();
prog.Minimum = 0;
prog.Maximum = 100;
if (e.Total >= e.Received)
prog.Value = (int)Math.Round((((double)e.Received / (double)e.Total) * 100.0d));
else
prog.Value = 0;
// List item
item = new GlacialComponents.Controls.GLItem();
item.SubItems[0].Text = e.ImageID.ToString();
item.SubItems[1].Control = prog;
DownloadList[e.ImageID] = item;
BeginInvoke(
(MethodInvoker)delegate()
{
lstDownloads.Items.Add(item);
lstDownloads.Invalidate();
});
}
}
}
#endregion Texture Downloading
private void frmBrowser_FormClosing(object sender, FormClosingEventArgs e)
{
DoLogout();
Application.Idle -= IdleEvent;
}
private void Application_Idle(object sender, EventArgs e)
{
while (AppStillIdle)
{
RenderScene();
}
}
private void cmdLogin_Click(object sender, EventArgs e)
{
if (cmdLogin.Text == "Login")
{
// Check that all the input boxes are filled in
if (txtFirst.Text.Length == 0)
{
txtFirst.Select();
return;
}
if (txtLast.Text.Length == 0)
{
txtLast.Select();
return;
}
if (txtPass.Text.Length == 0)
{
txtPass.Select();
return;
}
// Disable input controls
txtFirst.Enabled = txtLast.Enabled = txtPass.Enabled = false;
cmdLogin.Text = "Logout";
// Sanity check that we aren't already logged in
if (Client != null && Client.Network.Connected)
{
Client.Network.Logout();
}
// Re-initialize everything
InitializeObjects();
// Start the login
LoginParams loginParams = Client.Network.DefaultLoginParams(txtFirst.Text, txtLast.Text,
txtPass.Text, "Prim Preview", "0.0.1");
if (!String.IsNullOrEmpty(cboServer.Text))
loginParams.URI = cboServer.Text;
Client.Network.BeginLogin(loginParams);
}
else
{
DoLogout();
}
}
private void DoLogout()
{
if (Client != null && Client.Network.Connected)
{
Client.Network.Logout();
return;
}
// Clear the download list
lstDownloads.Items.Clear();
// Set the login button back to login state
cmdLogin.Text = "Login";
// Enable input controls
txtFirst.Enabled = txtLast.Enabled = txtPass.Enabled = true;
}
private void glControl_Resize(object sender, EventArgs e)
{
Gl.glClearColor(0.39f, 0.58f, 0.93f, 1.0f);
Gl.glViewport(0, 0, glControl.Width, glControl.Height);
Gl.glPushMatrix();
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
SetPerspective();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glPopMatrix();
// Set the center of the glControl as the default pivot point
LastPivot = glControl.PointToScreen(new Point(glControl.Width / 2, glControl.Height / 2));
}
private void glControl_MouseClick(object sender, MouseEventArgs e)
{
if ((Control.ModifierKeys & Keys.Alt) == 0 && e.Button == MouseButtons.Left)
{
// Only allow clicking if alt is not being held down
ClickX = e.X;
ClickY = e.Y;
Clicked = true;
}
}
private void glControl_MouseDown(object sender, MouseEventArgs e)
{
if ((Control.ModifierKeys & Keys.Alt) != 0 && LastHit > 0)
{
// Alt is held down and we have a valid target
Pivoting = true;
PivotPosition = Camera.FocalPoint;
Control control = (Control)sender;
LastPivot = control.PointToScreen(new Point(e.X, e.Y));
}
}
private void glControl_MouseMove(object sender, MouseEventArgs e)
{
if (Pivoting)
{
float a, x, y, z;
Control control = (Control)sender;
Point mouse = control.PointToScreen(new Point(e.X, e.Y));
// Calculate the deltas from the center of the control to the current position
int deltaX = (int)((mouse.X - LastPivot.X) * -0.5d);
int deltaY = (int)((mouse.Y - LastPivot.Y) * -0.5d);
// Translate so the focal point is the origin
Vector3 altered = Camera.Position - Camera.FocalPoint;
// Rotate the translated point by deltaX
a = (float)deltaX * DEG_TO_RAD;
x = (float)((altered.X * Math.Cos(a)) - (altered.Y * Math.Sin(a)));
y = (float)((altered.X * Math.Sin(a)) + (altered.Y * Math.Cos(a)));
altered.X = x;
altered.Y = y;
// Rotate the translated point by deltaY
a = (float)deltaY * DEG_TO_RAD;
y = (float)((altered.Y * Math.Cos(a)) - (altered.Z * Math.Sin(a)));
z = (float)((altered.Y * Math.Sin(a)) + (altered.Z * Math.Cos(a)));
altered.Y = y;
altered.Z = z;
// Translate back to world space
altered += Camera.FocalPoint;
// Update the camera
Camera.Position = altered;
UpdateCamera();
// Update the pivot point
LastPivot = mouse;
}
}
private void glControl_MouseWheel(object sender, MouseEventArgs e)
{
/*if (e.Delta != 0)
{
Camera.Zoom = Camera.Zoom + (double)(e.Delta / 120) * -0.1d;
if (Camera.Zoom < 0.05d) Camera.Zoom = 0.05d;
UpdateCamera();
}*/
if (e.Delta != 0)
{
// Calculate the distance to move to/away
float dist = (float)(e.Delta / 120) * 10.0f;
if (Vector3.Distance(Camera.Position, Camera.FocalPoint) > dist)
{
// Move closer or further away from the focal point
Vector3 toFocal = Camera.FocalPoint - Camera.Position;
toFocal.Normalize();
toFocal = toFocal * dist;
Camera.Position += toFocal;
UpdateCamera();
}
}
}
private void glControl_MouseUp(object sender, MouseEventArgs e)
{
// Stop pivoting if we were previously
Pivoting = false;
}
private void txtLogin_Enter(object sender, EventArgs e)
{
TextBox input = (TextBox)sender;
input.SelectAll();
}
private void cmdTeleport_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(txtSim.Text))
{
// Parse X/Y/Z
int x, y, z;
if (!Int32.TryParse(txtX.Text, out x))
{
txtX.SelectAll();
return;
}
if (!Int32.TryParse(txtY.Text, out y))
{
txtY.SelectAll();
return;
}
if (!Int32.TryParse(txtZ.Text, out z))
{
txtZ.SelectAll();
return;
}
string simName = txtSim.Text.Trim().ToLower();
Vector3 position = new Vector3(x, y, z);
if (Client != null && Client.Network.CurrentSim != null)
{
// Check for a local teleport to shortcut the process
if (simName == Client.Network.CurrentSim.Name.ToLower())
{
// Local teleport
Client.Self.RequestTeleport(Client.Network.CurrentSim.Handle, position);
}
else
{
// Cross-sim teleport
bool success = false;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object s, DoWorkEventArgs ea) { success = Client.Self.Teleport(simName, position); };
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs ea)
{
BeginInvoke((MethodInvoker)
delegate()
{
if (!success)
System.Windows.Forms.MessageBox.Show("Teleport failed");
});
};
worker.RunWorkerAsync();
}
}
else
{
// Oops! How did the user click this...
cmdTeleport.Enabled = false;
}
}
}
}
public struct TextureInfo
{
/// <summary>OpenGL Texture ID</summary>
public int ID;
/// <summary>True if this texture has an alpha component</summary>
public bool Alpha;
public TextureInfo(int id, bool alpha)
{
ID = id;
Alpha = alpha;
}
}
public struct HeightmapLookupValue : IComparable<HeightmapLookupValue>
{
public ushort Index;
public float Value;
public HeightmapLookupValue(ushort index, float value)
{
Index = index;
Value = value;
}
public int CompareTo(HeightmapLookupValue val)
{
return Value.CompareTo(val.Value);
}
}
public struct RenderablePrim
{
public Primitive Prim;
public FacetedMesh Mesh;
public readonly static RenderablePrim Empty = new RenderablePrim();
}
public struct Camera
{
public Vector3 Position;
public Vector3 FocalPoint;
public double Zoom;
public double Far;
}
public struct NativeMethods
{
[StructLayout(LayoutKind.Sequential)]
public struct Message
{
public IntPtr HWnd;
public uint Msg;
public IntPtr WParam;
public IntPtr LParam;
public uint Time;
public System.Drawing.Point Point;
}
//[System.Security.SuppressUnmanagedCodeSecurity]
[DllImport("User32.dll", CharSet = CharSet.Auto)]
public static extern bool PeekMessage(out Message msg, IntPtr hWnd, uint messageFilterMin, uint messageFilterMax, uint flags);
}
public static class Math3D
{
// Column-major:
// | 0 4 8 12 |
// | 1 5 9 13 |
// | 2 6 10 14 |
// | 3 7 11 15 |
public static float[] CreateTranslationMatrix(Vector3 v)
{
float[] mat = new float[16];
mat[12] = v.X;
mat[13] = v.Y;
mat[14] = v.Z;
mat[0] = mat[5] = mat[10] = mat[15] = 1;
return mat;
}
public static float[] CreateRotationMatrix(Quaternion q)
{
float[] mat = new float[16];
// Transpose the quaternion (don't ask me why)
q.X = q.X * -1f;
q.Y = q.Y * -1f;
q.Z = q.Z * -1f;
float x2 = q.X + q.X;
float y2 = q.Y + q.Y;
float z2 = q.Z + q.Z;
float xx = q.X * x2;
float xy = q.X * y2;
float xz = q.X * z2;
float yy = q.Y * y2;
float yz = q.Y * z2;
float zz = q.Z * z2;
float wx = q.W * x2;
float wy = q.W * y2;
float wz = q.W * z2;
mat[0] = 1.0f - (yy + zz);
mat[1] = xy - wz;
mat[2] = xz + wy;
mat[3] = 0.0f;
mat[4] = xy + wz;
mat[5] = 1.0f - (xx + zz);
mat[6] = yz - wx;
mat[7] = 0.0f;
mat[8] = xz - wy;
mat[9] = yz + wx;
mat[10] = 1.0f - (xx + yy);
mat[11] = 0.0f;
mat[12] = 0.0f;
mat[13] = 0.0f;
mat[14] = 0.0f;
mat[15] = 1.0f;
return mat;
}
public static float[] CreateScaleMatrix(Vector3 v)
{
float[] mat = new float[16];
mat[0] = v.X;
mat[5] = v.Y;
mat[10] = v.Z;
mat[15] = 1;
return mat;
}
}
}