static bool VirindiViewsPresent(Decal.Adapter.Wrappers.PluginHost pHost)
        {
#if VVS_REFERENCED
            System.Reflection.Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();

            foreach (System.Reflection.Assembly a in asms)
            {
                AssemblyName nmm = a.GetName();
                if ((nmm.Name == "VirindiViewService") && (nmm.Version >= new System.Version("1.0.0.37")))
                {
                    try
                    {
                        return Curtain_VVS_Running();
                    }
                    catch
                    {
                        return false;
                    }
                }
            }

            return false;
#else
            return false;
#endif
        }

 private void CharacterFilter_ChangePortalMode(object sender, Decal.Adapter.Wrappers.ChangePortalModeEventArgs e)
 {
     if (e.Type == this._expectedPortalEventType)
     {
         this._event.Set();
     }
 }

    public static void BuildDecalForObject(Decal decal, GameObject affectedObject)
    {
        Mesh affectedMesh = affectedObject.GetComponent<MeshFilter>().sharedMesh;
        if(affectedMesh == null) return;

        float maxAngle = decal.maxAngle;

        Plane right = new Plane( Vector3.right, Vector3.right/2f );
        Plane left = new Plane( -Vector3.right, -Vector3.right/2f );

        Plane top = new Plane( Vector3.up, Vector3.up/2f );
        Plane bottom = new Plane( -Vector3.up, -Vector3.up/2f );

        Plane front = new Plane( Vector3.forward, Vector3.forward/2f );
        Plane back = new Plane( -Vector3.forward, -Vector3.forward/2f );

        Vector3[] vertices = affectedMesh.vertices;
        int[] triangles = affectedMesh.triangles;
        int startVertexCount = bufVertices.Count;

        Matrix4x4 matrix = decal.transform.worldToLocalMatrix * affectedObject.transform.localToWorldMatrix;

        for(int i=0; i<triangles.Length; i+=3) {
            int i1 = triangles[i];
            int i2 = triangles[i+1];
            int i3 = triangles[i+2];

            Vector3 v1 = matrix.MultiplyPoint( vertices[i1] );
            Vector3 v2 = matrix.MultiplyPoint( vertices[i2] );
            Vector3 v3 = matrix.MultiplyPoint( vertices[i3] );

            Vector3 side1 = v2 - v1;
            Vector3 side2 = v3 - v1;
            Vector3 normal = Vector3.Cross(side1, side2).normalized;

            if( Vector3.Angle(-Vector3.forward, normal) >= maxAngle ) continue;

            DecalPolygon poly = new DecalPolygon( v1, v2, v3 );

            poly = DecalPolygon.ClipPolygon(poly, right);
            if(poly == null) continue;
            poly = DecalPolygon.ClipPolygon(poly, left);
            if(poly == null) continue;

            poly = DecalPolygon.ClipPolygon(poly, top);
            if(poly == null) continue;
            poly = DecalPolygon.ClipPolygon(poly, bottom);
            if(poly == null) continue;

            poly = DecalPolygon.ClipPolygon(poly, front);
            if(poly == null) continue;
            poly = DecalPolygon.ClipPolygon(poly, back);
            if(poly == null) continue;

            AddPolygon( poly, normal );
        }

        GenerateTexCoords(startVertexCount, decal.sprite);
    }

 public void InitializeRawXML(Decal.Adapter.Wrappers.PluginHost p, string pXML, string pWindowKey)
 {
     VirindiViewService.XMLParsers.Decal3XMLParser ps = new VirindiViewService.XMLParsers.Decal3XMLParser();
     ViewProperties iprop;
     ControlGroup igroup;
     ps.Parse(pXML, out iprop, out igroup);
     myView = new VirindiViewService.HudView(iprop, igroup, pWindowKey);
 }

 void _decalEvents_SpellCast(object sender, Decal.Adapter.Wrappers.SpellCastEventArgs e)
 {
     switch (e.SpellId)
     {
         case Data.SpellIds.LifestoneRecall:
             this.OnSelfLifestoneRecall();
             break;
     }
 }

		void CharacterFilter_Login(object sender, Decal.Adapter.Wrappers.LoginEventArgs e)
		{
			try
			{
				if (!Settings.SettingsManager.Misc.RemoveWindowFrame.Value)
					return;

				RemoveWindowFrame();
			}
			catch (Exception ex) { Debug.LogException(ex); }
		}

		void CharacterFilter_Death(object sender, Decal.Adapter.Wrappers.DeathEventArgs e)
		{
			try
			{
				if (!Settings.SettingsManager.Misc.LogOutOnDeath.Value)
					return;

				CoreManager.Current.Actions.Logout();
			}
			catch (Exception ex) { Debug.LogException(ex); }
		}

 void CoreManager_ChatBoxMessage(object sender, Decal.Adapter.ChatTextInterceptEventArgs e)
 {
     REPlugin.Instance.InvokeOperationSafely(() =>
     {
         ChatEvent chatEvent;
         if (ChatEvent.TryParse(e.Text, out chatEvent))
         {
             this.HandleChatEvent(chatEvent);
         }
     });
 }

	private void GenerateUV(Decal d)
	{
		if(d.GetComponent<MeshFilter>() == null) return;
		
		Mesh m = d.GetComponent<MeshFilter>().sharedMesh;
		
		Vector2[] uv = Unwrapping.GeneratePerTriangleUV(m);
			
        MeshUtility.SetPerTriangleUV2(m, uv);

        Unwrapping.GenerateSecondaryUVSet(m);
	}

        ///////////////////////////////System presence detection///////////////////////////////

        public static bool IsPresent(Decal.Adapter.Wrappers.PluginHost pHost, eViewSystem VSystem)
        {
            switch (VSystem)
            {
                case eViewSystem.DecalInject:
                    return true;
                case eViewSystem.VirindiViewService:
                    return VirindiViewsPresent(pHost);
                default:
                    return false;
            }
        }

        private void ChangePortalModeCorpses(object sender, Decal.Adapter.Wrappers.ChangePortalModeEventArgs e)
        {
            try
            {
                CorpseTrackingList.Clear();
                foreach(WorldObject wo in Core.WorldFilter.GetByObjectClass(ObjectClass.Corpse))
                {
                    if(!CorpseTrackingList.Any(x => x.Id == wo.Id)){CheckCorpse(new LandscapeObject(wo));}
                }
             		UpdateCorpseHud();

            }catch(Exception ex){LogError(ex);}
        }

 void _decalEventsProxy_ChatBoxMessage(object sender, Decal.Adapter.ChatTextInterceptEventArgs e)
 {
     ICommand command;
     if (CommandHelpers.TryParse(e, out command))
     {
         switch (command.CommandType)
         {
             case CommandType.Foreign:
                 // Never eat ...Then I can't see the /f messages i'm causing...while others still can
                 Handlers.ForeignHandler.HandleCommand(command);
                 break;
         }
     }
 }

 void _decalEventsProxy_CommandLineText(object sender, Decal.Adapter.ChatParserInterceptEventArgs e)
 {
     ICommand command;
     if (CommandHelpers.TryParse(e, out command))
     {
         switch (command.CommandType)
         {
             case CommandType.RedoxExtension:
                 e.Eat = Handlers.RedoxExtensionsHandler.HandleCommand(command);
                 break;
             case CommandType.RedoxFellow:
                 e.Eat = Handlers.RedoxFellowHandler.HandleCommand(command);
                 break;
         }
     }
 }

		void CharacterFilter_Login(object sender, Decal.Adapter.Wrappers.LoginEventArgs e)
		{
			try
			{
				WindowPosition windowPosition;

				if (GetWindowPositionForThisClient(out windowPosition))
				{
					User32.RECT rect = new User32.RECT();

					User32.GetWindowRect(CoreManager.Current.Decal.Hwnd, ref rect);

					User32.MoveWindow(CoreManager.Current.Decal.Hwnd, windowPosition.X, windowPosition.Y, rect.Right - rect.Left, rect.Bottom - rect.Top, true);
				}
			}
			catch (Exception ex) { Debug.LogException(ex); }
		}

        private void DecalCore_CommandLineText(object sender, Decal.Adapter.ChatParserInterceptEventArgs e)
        {
            REWrapperPlugin.Instance.InvokeOperationSafely(() =>
            {
                if (e.Text.StartsWith(CommandPrefix_Legacy))
                {
                    var command = e.Text.Substring(CommandPrefix_Legacy.Length + 1).Trim();

                    e.Eat = this.HandleNormalCommand(command, true);
                }
                else if (e.Text.StartsWith(CommandPrefix))
                {
                    var command = e.Text.Substring(CommandPrefix.Length + 1).Trim();

                    e.Eat = this.HandleNormalCommand(command, false);
                }
            });
        }

        private void CharacterFilter_ChangePortalMode(object sender, Decal.Adapter.Wrappers.ChangePortalModeEventArgs e)
        {
            lock (this._lock)
            {
                if (this._complete)
                {
                    return;
                }

                this._complete = true;

                if (e.Type == this._expectedPortalEventType)
                {
                    this._onEventAction(this._stateTag);

                    this.CleanUpAndComplete();
                }
            }
        }

		void CharacterFilter_Login(object sender, Decal.Adapter.Wrappers.LoginEventArgs e)
		{
			try
			{
				var loginCommands = Settings.SettingsManager.AccountServerCharacter.GetOnLoginCommands(CoreManager.Current.CharacterFilter.AccountName, CoreManager.Current.CharacterFilter.Server, CoreManager.Current.CharacterFilter.Name);

				foreach (var command in loginCommands)
				{
					HudList.HudListRowAccessor newRow = loginList.AddRow();

					((HudStaticText)newRow[0]).Text = command;
					((HudPictureBox)newRow[1]).Image = 0x60028FC;
					((HudPictureBox)newRow[2]).Image = 0x60028FD;
					((HudPictureBox)newRow[3]).Image = 0x60011F8;
				}

				var loginCompleteCommands = Settings.SettingsManager.AccountServerCharacter.GetOnLoginCompleteCommands(CoreManager.Current.CharacterFilter.AccountName, CoreManager.Current.CharacterFilter.Server, CoreManager.Current.CharacterFilter.Name);

				foreach (var command in loginCompleteCommands)
				{
					HudList.HudListRowAccessor newRow = loginCompleteList.AddRow();

					((HudStaticText)newRow[0]).Text = command;
					((HudPictureBox)newRow[1]).Image = 0x60028FC;
					((HudPictureBox)newRow[2]).Image = 0x60028FD;
					((HudPictureBox)newRow[3]).Image = 0x60011F8;
				}

				var periodicCommands = Settings.SettingsManager.AccountServerCharacter.GetPeriodicCommands(CoreManager.Current.CharacterFilter.AccountName, CoreManager.Current.CharacterFilter.Server, CoreManager.Current.CharacterFilter.Name);

				foreach (var command in periodicCommands)
				{
					HudList.HudListRowAccessor newRow = periodicCommandList.AddRow();

					((HudStaticText)newRow[0]).Text = command.Command;
					((HudStaticText)newRow[1]).Text = command.Interval.TotalMinutes.ToString(CultureInfo.InvariantCulture);
					((HudStaticText)newRow[2]).Text = command.OffsetFromMidnight.TotalMinutes.ToString(CultureInfo.InvariantCulture);
					((HudPictureBox)newRow[3]).Image = 0x60011F8;
				}
			}
			catch (Exception ex) { Debug.LogException(ex); }
		}

        private void CoreManager_CommandLineText(object sender, Decal.Adapter.ChatParserInterceptEventArgs e)
        {
            REPlugin.Instance.InvokeOperationSafely(() =>
            {
                ChatEvent chatEvent;
                if (ChatEvent.TryParse(e.Text, out chatEvent))
                {
                    if (chatEvent.SourceName.Equals(this._expectedSourceName, StringComparison.InvariantCultureIgnoreCase))
                    {
                        this._tellReceivedWaitHandle.Set();

                        if (this._unhookOnMatch)
                        {
                            this._unhooked = true;
                            REPlugin.Instance.CoreManager.CommandLineText -= CoreManager_CommandLineText;
                        }
                    }
                }
            });
        }

		void CharacterFilter_Login(object sender, Decal.Adapter.Wrappers.LoginEventArgs e)
		{
			try
			{
				var commands = Settings.SettingsManager.AccountServerCharacter.GetOnLoginCommands(CoreManager.Current.CharacterFilter.AccountName, CoreManager.Current.CharacterFilter.Server, CoreManager.Current.CharacterFilter.Name);

				if (commands.Count == 0)
					return;

				if (pendingCommands.Count == 0)
					CoreManager.Current.RenderFrame += new EventHandler<EventArgs>(Current_RenderFrame);

				// This queues up a dummy command so our actions happen one frame after all the other plugins have finished Login
				pendingCommands.Enqueue(null);

				foreach (var action in commands)
					pendingCommands.Enqueue(action);
			}
			catch (Exception ex) { Debug.LogException(ex); }
		}

        private void DecalEventsProxy_ChatBoxMessage(object sender, Decal.Adapter.ChatTextInterceptEventArgs e)
        {
            if (ChatParsingUtilities.IsChat(e.Text, this._chatFilter) && ChatParsingUtilities.IsChannel(e.Text, this._channelFilter))
            {
                if (this.FilteredChatBoxMessage != null)
                {
                    this.FilteredChatBoxMessage(sender, e);
                }

                // Only try to parse if someone is listening
                if (this.FilteredAndParsedChatBoxMessage != null)
                {
                    ParsedChatTextInterceptEventArgs parsedEventArgs = null;
                    if (ParsedChatTextInterceptEventArgs.TryCreateFrom(e, out parsedEventArgs))
                    {
                        this.FilteredAndParsedChatBoxMessage(sender, parsedEventArgs);

                        e.Eat = parsedEventArgs.Eat;
                    }
                }
            }
        }