bool WriteFrame(Frame a_frame)
{
if (!m_internalClient.IsConnected)
{
InternalConsole.AddMessage("Failed to write to disconnected stream");
}
try
{
m_internalClient.WriteToStream(a_frame.ToBytes());
return(true);
}
catch (IOException e)
{
InternalConsole.Error(string.Format("Discord Client: Failed to write frame: IOException: {0}", e.Message));
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Failed to write frame: Disposed");
}
catch (InvalidOperationException)
{
InternalConsole.Error("Discord Client: Invalid Operaion when writing frame");
}
return(false);
}
public void ModifyObject()
{
m_handle = GL.CreateProgram();
PixelShader pixelShader = m_program.PixelShader;
GeometryShader geometryShader = m_program.GeometryShader;
VertexShader vertexShader = m_program.VertexShader;
if (pixelShader != null)
{
GL.AttachShader(m_handle, ((OpenTKPixelShader)pixelShader.InternalObject).Handle);
}
if (geometryShader != null)
{
GL.AttachShader(m_handle, ((OpenTKGeometryShader)geometryShader.InternalObject).Handle);
}
if (vertexShader != null)
{
GL.AttachShader(m_handle, ((OpenTKVertexShader)vertexShader.InternalObject).Handle);
}
GL.LinkProgram(m_handle);
#if DEBUG_INFO
string info;
GL.GetProgramInfoLog(m_handle, out info);
if (!string.IsNullOrEmpty(info))
{
InternalConsole.AddMessage(info, InternalConsole.e_Alert.Warning);
}
#endif
}
public static Canvas LoadGUI(string a_filename, IFileSystem a_fileSystem, Pipeline a_pipeline)
{
if (a_fileSystem != null)
{
Stream stream;
if (a_fileSystem.Load(a_filename, out stream))
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(stream);
Canvas canv = Load(xmlDocument, a_fileSystem, a_pipeline);
if (canv != null)
{
canv.m_fileSystem = a_fileSystem;
}
return(canv);
}
else
{
InternalConsole.Error("Cannot access canvas file");
}
}
else
{
InternalConsole.Error("No filesystem to load from for canvas");
}
return(null);
}
void Error(IntPtr a_errorStr)
{
string str = Marshal.PtrToStringAnsi(a_errorStr);
if (!string.IsNullOrEmpty(str))
{
InternalConsole.Error(str);
}
}
public static void GLError(string a_error)
{
ErrorCode error = GL.GetError();
if (error != ErrorCode.NoError)
{
InternalConsole.AddMessage(a_error + error.ToString(), InternalConsole.e_Alert.Error);
}
}
public Device()
{
if (m_activeDevice == null)
{
m_activeDevice = this;
}
InitContext();
InternalConsole.AddMessage(string.Format("Init OpenAL: Version: {0}, Vendor {1}, Renderer {2}", AL.Get(ALGetString.Version), AL.Get(ALGetString.Vendor), AL.Get(ALGetString.Renderer)));
}
void ProcessCommandQueue()
{
if (m_state != e_RPCState.Connected)
{
return;
}
bool write = m_commandQueue.Count > 0;
ICommand command = null;
while (write && m_internalClient.IsConnected)
{
command = m_commandQueue.Peek();
if (command is CloseCommand)
{
m_state = e_RPCState.Disconnected;
if (!WriteFrame(new Frame(Frame.e_OpCode.Close, new Handshake()
{
Version = m_version, ClientID = m_clientID
})))
{
InternalConsole.Error("Discord Client: Handwave Failed");
}
return;
}
else
{
IPayload payload = command.PreparePayload(m_nounce++);
Frame frame = new Frame();
if (!m_shutdown)
{
frame.OpCode = Frame.e_OpCode.Frame;
frame.SetObject(payload);
WriteFrame(frame);
}
}
m_commandQueue.Dequeue();
write = m_commandQueue.Count > 0;
}
}
public void ModifyObject()
{
int shader = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(shader, m_source);
GL.CompileShader(shader);
m_shader.Handle = shader;
#if DEBUG_INFO
string info = GL.GetShaderInfoLog(shader);
if (info != string.Empty)
{
InternalConsole.AddMessage(info, InternalConsole.e_Alert.Warning);
}
#endif
}
void ProcessEvent(EventPayload a_event)
{
if (a_event.Event.HasValue && a_event.Event == EventPayload.e_ServerEvent.Error)
{
ErrorMessage error = a_event.GetObject <ErrorMessage>();
InternalConsole.Error(string.Format("Discord responded with error: ({0}) {1}", error.ErrorCode, error.Message));
EnqueueMessage(error);
}
if (m_state == e_RPCState.Connecting)
{
if (a_event.Command == e_Command.Dispatch && a_event.Event.HasValue && a_event.Event.Value == EventPayload.e_ServerEvent.Ready)
{
m_state = e_RPCState.Connected;
ReadyMessage ready = a_event.GetObject <ReadyMessage>();
m_config = ready.Configuration;
User user = ready.User;
user.Configuration = ready.Configuration;
ready.User = user;
m_user = user;
EnqueueMessage(ready);
return;
}
}
// TODO: Implement Connected Commands
if (m_state == e_RPCState.Connected)
{
switch (a_event.Command)
{
case e_Command.Dispatch:
{
break;
}
}
}
}
void Handshake()
{
InternalConsole.AddMessage("Attempting Discord Handshake");
if (m_state != e_RPCState.Disconnected)
{
InternalConsole.Warning("Discord Client: State must be disconnected to handshake");
return;
}
if (WriteFrame(new Frame(Frame.e_OpCode.Handshake, new Handshake()
{
Version = m_version, ClientID = m_clientID
})))
{
m_state = e_RPCState.Connecting;
}
}
void EndRead(IAsyncResult a_callback)
{
int bytes = -1;
try
{
bytes = m_stream.EndRead(a_callback);
}
catch (IOException)
{
InternalConsole.Error("Discord Client: Attempted to read from closed pipe");
return;
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Attempted to end reading from a disposed pipe");
return;
}
catch (NullReferenceException)
{
InternalConsole.Error("Discord Client: Attempted to connect to null pipe");
return;
}
if (bytes > 0)
{
Frame frame = Frame.FromBytes(m_buffer);
if (frame != null)
{
Client.EnqueueFrame(frame);
}
}
if (m_stream.IsConnected)
{
BeginRead();
}
}
void Disposal()
{
while (!m_disposalQueue.IsEmpty)
{
IRenderObject obj;
if (!m_disposalQueue.TryDequeue(out obj))
{
InternalConsole.AddMessage("Graphics: Diposal Dequeue Failed", InternalConsole.e_Alert.Error);
return;
}
obj.RemoveObject(m_drawingObjects, m_updateRenderers);
#if DEBUG_INFO
Pipeline.GLError("Graphics: Disposal: ");
#endif
}
}
void Disposal()
{
while (!m_disposalQueue.IsEmpty)
{
IGraphicsObject obj;
if (!m_disposalQueue.TryDequeue(out obj))
{
InternalConsole.AddMessage("Pipeline: Disposal Dequeue Failed", InternalConsole.e_Alert.Warning);
return;
}
obj.DisposeObject();
#if DEBUG_INFO
Pipeline.GLError("Pipeline: Disposal: ");
#endif
}
}
public override bool AttemptConnection(string a_pipe)
{
m_socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
m_socket.Blocking = false;
UnixEndPoint endPoint = new UnixEndPoint(string.Format("{0}/{1}", m_envPath, a_pipe));
try
{
m_socket.Connect(endPoint);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Failed to connect to {0}: {1}", a_pipe, e.Message));
return(false);
}
return(true);
}
void Input()
{
while (!m_inputQueue.IsEmpty)
{
IGraphicsObject obj;
if (!m_inputQueue.TryDequeue(out obj))
{
InternalConsole.AddMessage("Pipeline: Input Dequeue Failed", InternalConsole.e_Alert.Warning);
return;
}
obj.ModifyObject();
#if DEBUG_INFO
Pipeline.GLError("Pipeline: Input: ");
#endif
}
}
void Input()
{
while (!m_inputQueue.IsEmpty)
{
IRenderObject obj;
if (!m_inputQueue.TryDequeue(out obj))
{
InternalConsole.AddMessage("Graphics: Input Dequeue Failed", InternalConsole.e_Alert.Error);
return;
}
obj.AddObject(m_drawingObjects, m_updateRenderers);
#if DEBUG_INFO
Pipeline.GLError("Graphics: Input: ");
#endif
}
}
void Input()
{
while (!m_inputQueue.IsEmpty)
{
IPObject pObject;
if (!m_inputQueue.TryDequeue(out pObject))
{
InternalConsole.Warning("Physics Engine: Failed to dequeue for writing");
return;
}
pObject.ModifyObject();
CollisionObject collisionObject = pObject as CollisionObject;
if (collisionObject != null && !m_collisionObjects.Contains(collisionObject))
{
m_collisionObjects.Add(collisionObject);
}
}
}
void Disposal()
{
while (!m_disposalQueue.IsEmpty)
{
IPObject pObject;
if (!m_disposalQueue.TryDequeue(out pObject))
{
InternalConsole.Warning("Physics Engine: Failed to dequeue for disposal");
return;
}
pObject.DisposeObject();
CollisionObject collisionObject = pObject as CollisionObject;
if (collisionObject != null && m_collisionObjects.Contains(collisionObject))
{
m_collisionObjects.Remove(collisionObject);
}
}
}
public override bool AttemptConnection(string a_pipe)
{
try
{
m_stream = new NamedPipeClientStream(".", a_pipe, PipeDirection.InOut, PipeOptions.Asynchronous);
m_stream.Connect(1000);
do
{
Thread.Sleep(10);
}while (!m_stream.IsConnected);
InternalConsole.AddMessage(string.Format("Connected: {0}", a_pipe));
return(true);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Failed to connect to {0}: {1}", a_pipe, e.Message));
}
return(false);
}
static void Main(string[] args)
{
InternalConsole.Init();
while (true)
{
Console.Write(_consoleChars);
var line = Console.ReadLine();
if (line == null)
{
continue;
}
if (!string.IsNullOrWhiteSpace(line) && line.Trim().Equals("quit", StringComparison.OrdinalIgnoreCase))
{
break;
}
if (!string.IsNullOrWhiteSpace(line) && line.Trim().Equals("cls", StringComparison.OrdinalIgnoreCase))
{
Console.Clear();
continue;
}
if (line.Trim().Equals("car status", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine($"");
Console.WriteLine($"CAR STATUS");
Console.WriteLine($"Angle: {Car.Angle}");
Console.WriteLine($"Speed: {Car.Speed}");
Console.WriteLine($"X: {Car.X}");
Console.WriteLine($"X: {Car.Y}");
Console.WriteLine($"");
}
}
}
public override void BeginRead()
{
if (!m_socket.Connected)
{
return;
}
try
{
byte[] buffer = new byte[1024 * 16];
SocketAsyncEventArgs eventArgs = new SocketAsyncEventArgs();
eventArgs.SetBuffer(buffer, 0, buffer.Length);
eventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(EndRead);
m_socket.ReceiveAsync(eventArgs);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Discord Client: Reading socket: {0}", e.Message));
return;
}
}
public override void BeginRead()
{
if (!m_stream.IsConnected)
{
return;
}
try
{
m_stream.BeginRead(m_buffer, 0, m_buffer.Length, EndRead, m_stream.IsConnected);
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Attempted to read from disposed stream");
return;
}
catch (InvalidOperationException)
{
InternalConsole.Error("Discord Client: Attempted to read from closed pipe");
return;
}
}
void PopulateElements(XmlNode a_node, Element a_parent)
{
if (a_node.NodeType == XmlNodeType.Comment)
{
return;
}
Type type = Type.GetType(a_node.Name);
if (type == null)
{
type = Type.GetType("Erde.Graphics.GUI." + a_node.Name);
if (type == null)
{
InternalConsole.Error("Canvas: Invalid Element Type: " + a_node.Name);
return;
}
}
MethodInfo methodInfo = type.GetMethod("Create", BindingFlags.Static | BindingFlags.NonPublic);
Element element = methodInfo.Invoke(null, new object[] { a_node, m_fileSystem, m_pipeline }) as Element;
if (element != null)
{
foreach (XmlAttribute att in a_node.Attributes)
{
switch (att.Name.ToLower())
{
case "visible":
{
element.Visible = bool.Parse(att.Value);
break;
}
case "width":
{
Vector2 size = element.Size;
size.X = float.Parse(att.Value);
element.Size = size;
break;
}
case "height":
{
Vector2 size = element.Size;
size.Y = float.Parse(att.Value);
element.Size = size;
break;
}
case "xpos":
{
Vector2 pos = element.Position;
pos.X = float.Parse(att.Value);
element.Position = pos;
break;
}
case "ypos":
{
Vector2 pos = element.Position;
pos.Y = float.Parse(att.Value);
element.Position = pos;
break;
}
case "xlock":
{
for (int i = 0; i < (int)e_XLockMode.End; ++i)
{
e_XLockMode lockMode = (e_XLockMode)i;
if (lockMode.ToString().ToLower() == att.Value.ToLower())
{
element.XLockMode = lockMode;
break;
}
}
break;
}
case "ylock":
{
for (int i = 0; i < (int)e_YLockMode.End; ++i)
{
e_YLockMode lockMode = (e_YLockMode)i;
if (lockMode.ToString().ToLower() == att.Value.ToLower())
{
element.YLockMode = lockMode;
break;
}
}
break;
}
case "name":
{
if (!string.IsNullOrEmpty(att.Value))
{
m_namedElements.Add(att.Value, element);
}
break;
}
case "onhover":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Hover += dele;
}
}
break;
}
case "onnormal":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Normal += dele;
}
}
break;
}
case "onclick":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Click += dele;
}
}
break;
}
case "onrelease":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Release += dele;
}
}
break;
}
case "submenu":
{
element.SubMenuDirectory = att.Value;
break;
}
}
}
m_elements.Add(element);
foreach (XmlNode node in a_node.ChildNodes)
{
PopulateElements(node, element);
}
if (a_parent != null)
{
element.Parent = a_parent;
}
element.State = Element.e_State.Normal;
if (element.Normal != null)
{
element.Normal.Invoke(this, element);
}
}
}
void DiscordLoop()
{
bool connected = false;
m_join = false;
for (int i = 0; i < 10; ++i)
{
if (AttemptConnection(i))
{
connected = true;
break;
}
if (m_shutdown)
{
break;
}
}
if (!connected)
{
InternalConsole.Error("Failed to connect to Discord");
m_shutdown = true;
}
else
{
m_internalClient.BeginRead();
EnqueueMessage(new ConnectionEstablishedMessage(m_connectedPipe));
Handshake();
while (!m_shutdown)
{
Frame frame;
if (ReadFrame(out frame))
{
switch (frame.OpCode)
{
case Frame.e_OpCode.Close:
{
ClosePayload close = frame.GetObject <ClosePayload>();
InternalConsole.AddMessage("Discord Client Remotely Terminated");
EnqueueMessage(new CloseMessage(close.Code, close.Reason));
m_shutdown = true;
break;
}
case Frame.e_OpCode.Ping:
{
WriteFrame(new Frame(Frame.e_OpCode.Pong, frame.Data));
break;
}
case Frame.e_OpCode.Pong:
{
InternalConsole.Warning("Got a pong from Discord?");
break;
}
case Frame.e_OpCode.Frame:
{
if (m_shutdown)
{
break;
}
if (frame.Data == null)
{
InternalConsole.Error("Discord Client: No data in frame");
}
EventPayload response = frame.GetObject <EventPayload>();
ProcessEvent(response);
break;
}
default:
{
InternalConsole.Error("Discord Client: Invalid Operation");
m_shutdown = true;
break;
}
}
}
ProcessCommandQueue();
}
ProcessCommandQueue();
}
m_join = true;
}
void Awake()
{
instance = this;
consoleLocalRect = consoleRect;
}
public OBJLoader(string a_fileName, IFileSystem a_fileSystem)
{
m_vertices = new List <Vertex>();
m_indices = new List <uint>();
byte[] bytes;
if (a_fileSystem.Load(a_fileName, out bytes))
{
string[] lines = Encoding.UTF8.GetString(bytes).Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
List <Vector3> vertexPosition = new List <Vector3>();
List <Vector3> vertexNormal = new List <Vector3>();
List <Vector2> vertexTextureCoords = new List <Vector2>();
Dictionary <Vertex, uint> vertexLookup = new Dictionary <Vertex, uint>();
float lengthSqr = 0.0f;
foreach (string line in lines)
{
string l = line.ToLower();
int index = l.IndexOf(' ');
string data = l.Substring(index + 1, l.Length - (index + 1));
switch (l.Substring(0, index))
{
case "#":
case "o":
{
break;
}
case "v":
{
Vector3 vertex = Vector3.Zero;
string[] strings = data.Split(' ');
vertex.X = float.Parse(strings[0]);
vertex.Y = float.Parse(strings[1]);
vertex.Z = float.Parse(strings[2]);
lengthSqr = Math.Max(lengthSqr, vertex.LengthSquared);
vertexPosition.Add(vertex);
break;
}
case "vn":
{
Vector3 vertex = Vector3.Zero;
string[] strings = data.Split(' ');
vertex.X = float.Parse(strings[0]);
vertex.Y = float.Parse(strings[1]);
vertex.Z = float.Parse(strings[2]);
vertexNormal.Add(vertex);
break;
}
case "vt":
{
Vector2 vertex = Vector2.Zero;
string[] strings = data.Split(' ');
vertex.X = float.Parse(strings[0]);
vertex.Y = 1 - float.Parse(strings[1]);
vertexTextureCoords.Add(vertex);
break;
}
case "f":
{
string[] strings = data.Split(' ');
foreach (string s in strings)
{
string[] ind = s.Split('/');
Vertex vert = new Vertex()
{
Position = new Vector4(vertexPosition[int.Parse(ind[0]) - 1], 1)
};
if (ind.Length == 2)
{
if (s.Count(f => f == '/') == 2)
{
vert.Normal = vertexNormal[int.Parse(ind[1]) - 1];
}
else
{
vert.TexCoords = vertexTextureCoords[int.Parse(ind[1]) - 1];
}
}
else
{
vert.TexCoords = vertexTextureCoords[int.Parse(ind[1]) - 1];
vert.Normal = vertexNormal[int.Parse(ind[2]) - 1];
}
uint val = 0;
if (!vertexLookup.TryGetValue(vert, out val))
{
m_vertices.Add(vert);
val = (ushort)(m_vertices.Count - 1);
vertexLookup.Add(vert, val);
}
m_indices.Add(val);
}
break;
}
}
}
m_length = (float)Math.Sqrt(lengthSqr);
}
else
{
InternalConsole.Warning("Failed to Load: " + a_fileName);
}
}
