ArtemisClientLoop.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UI;

public class ArtemisClientLoop : MonoBehaviour {

    private static bool toggleTotalEnergyPlot = false;
    private static bool toggleHBondsEnergyPlot = false;
    private static bool toggleStackingEnergyPlot = false;

    public static Texture2D totalEnergyPlotTexture;
    public static Texture2D hbondsEnergyPlotTexture;
    public static Texture2D stackingEnergyPlotTexture;

    public static GameObject totalEnergyGameObject;
    public static GameObject hbondsEnergyGameObject;
    public static GameObject stackingEnergyGameObject;

    public static void instanciateTotalEnergyPlot()
    {
        PlotManager.Instance.PlotCreate("Total Energy", -100, 2000, GUIDisplay.artemisPlotWhiteStyle.normal.textColor, ref ArtemisClientLoop.totalEnergyPlotTexture);

        totalEnergyGameObject = GameObject.CreatePrimitive(PrimitiveType.Quad);
        totalEnergyGameObject.name = "TotalEnergyPlot";

        totalEnergyGameObject.transform.parent = Camera.main.transform;
        totalEnergyGameObject.transform.LookAt(-Camera.main.transform.position);

        totalEnergyGameObject.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Transparent/Zsorted"));
        totalEnergyGameObject.GetComponent<MeshRenderer>().material.SetTexture("_MainTex", ArtemisClientLoop.totalEnergyPlotTexture);

        totalEnergyGameObject.AddComponent(typeof(DraggableBillboard));

        totalEnergyGameObject.transform.localPosition = new Vector3(0f, 0f, 3f);
        totalEnergyGameObject.transform.rotation = Camera.main.transform.rotation;

        toggleTotalEnergyPlot = true;
    }

    public static void activateTotalEnergyPlot()
    {
        toggleTotalEnergyPlot = true;
        totalEnergyGameObject.SetActive(true);
    }

    public static void deactivateTotalEnergyPlot()
    {
        totalEnergyGameObject.SetActive(false);

        toggleTotalEnergyPlot = false;
    }

    public static void destroyTotalEnergyPlot()
    {
        PlotManager.Instance.PlotDestroy("Total Energy");

        GameObject.Destroy(totalEnergyGameObject);

        toggleTotalEnergyPlot = false;
        LoadTypeGUI.toggleIMDTotalEnergy = false;
    }

    public static void instanciateHBondsEnergyPlot()
    {
        PlotManager.Instance.PlotCreate("Hydrogen Bonds Energy", -200, 200, GUIDisplay.artemisPlotGreenStyle.normal.textColor, ref ArtemisClientLoop.hbondsEnergyPlotTexture);

        hbondsEnergyGameObject = GameObject.CreatePrimitive(PrimitiveType.Quad);
        hbondsEnergyGameObject.name = "HBondsEnergyPlot";

        hbondsEnergyGameObject.transform.parent = Camera.main.transform;
        hbondsEnergyGameObject.transform.LookAt(-Camera.main.transform.position);

        hbondsEnergyGameObject.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Transparent/Zsorted"));
        hbondsEnergyGameObject.GetComponent<MeshRenderer>().material.SetTexture("_MainTex", ArtemisClientLoop.hbondsEnergyPlotTexture);

        hbondsEnergyGameObject.AddComponent(typeof(DraggableBillboard));

        hbondsEnergyGameObject.transform.localPosition = new Vector3(0f, 0f, 3f);
        hbondsEnergyGameObject.transform.rotation = Camera.main.transform.rotation;

        toggleHBondsEnergyPlot = true;
    }

    public static void activateHBondsEnergyPlot()
    {
        toggleHBondsEnergyPlot = true;
        hbondsEnergyGameObject.SetActive(true);
    }

    public static void deactivateHBondsEnergyPlot()
    {
        hbondsEnergyGameObject.SetActive(false);

        toggleHBondsEnergyPlot = false;
    }

    public static void destroyHBondsEnergyPlot()
    {
        PlotManager.Instance.PlotDestroy("Hydrogen Bonds Energy");

        GameObject.Destroy(hbondsEnergyGameObject);

        toggleHBondsEnergyPlot = false;
        LoadTypeGUI.toggleIMDHBondsEnergy = false;
    }

    public static void instantiateStackingEnergyPlot()
    {
        PlotManager.Instance.PlotCreate("Stacking Energy", -100, 40, GUIDisplay.artemisPlotRedStyle.normal.textColor, ref ArtemisClientLoop.stackingEnergyPlotTexture);

        stackingEnergyGameObject = GameObject.CreatePrimitive(PrimitiveType.Quad);
        stackingEnergyGameObject.name = "TotalEnergyPlot";

        stackingEnergyGameObject.transform.parent = Camera.main.transform;
        stackingEnergyGameObject.transform.LookAt(-Camera.main.transform.position);

        stackingEnergyGameObject.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Transparent/Zsorted"));
        stackingEnergyGameObject.GetComponent<MeshRenderer>().material.SetTexture("_MainTex", ArtemisClientLoop.stackingEnergyPlotTexture);

        stackingEnergyGameObject.AddComponent(typeof(DraggableBillboard));

        stackingEnergyGameObject.transform.localPosition = new Vector3(0f, 0f, 3f);
        stackingEnergyGameObject.transform.rotation = Camera.main.transform.rotation;

        toggleStackingEnergyPlot = true;
    }

    public static void activateStackingEnergyPlot()
    {
        toggleStackingEnergyPlot = true;
        stackingEnergyGameObject.SetActive(true);
    }

    public static void deactivateStackingEnergyPlot()
    {
        stackingEnergyGameObject.SetActive(false);

        toggleStackingEnergyPlot = false;
    }

    public static void destroyStackingEnergyPlot()
    {
        PlotManager.Instance.PlotDestroy("Stacking Energy");

        GameObject.Destroy(stackingEnergyGameObject);

        toggleStackingEnergyPlot = false;
        LoadTypeGUI.toggleIMDStackingEnergy = false;
    }

    void OnDestroy() {
        destroyTotalEnergyPlot();
        destroyStackingEnergyPlot();
        destroyHBondsEnergyPlot();
    }

    void Start () {
        instanciateTotalEnergyPlot();
        instanciateHBondsEnergyPlot();
        instantiateStackingEnergyPlot();
    }

    void Update () {
        if (LoadTypeGUI.toggleIMDTotalEnergy && !toggleTotalEnergyPlot)
        {
            activateTotalEnergyPlot();
        }
        if (!LoadTypeGUI.toggleIMDTotalEnergy && toggleTotalEnergyPlot)
        {
            deactivateTotalEnergyPlot();
        }

        if (LoadTypeGUI.toggleIMDHBondsEnergy && !toggleHBondsEnergyPlot)
        {
            activateHBondsEnergyPlot();
        }
        if (!LoadTypeGUI.toggleIMDHBondsEnergy && toggleHBondsEnergyPlot)
        {
            deactivateHBondsEnergyPlot();
        }

        if (LoadTypeGUI.toggleIMDStackingEnergy && !toggleStackingEnergyPlot)
        {
            activateStackingEnergyPlot();
        }
        if (!LoadTypeGUI.toggleIMDStackingEnergy && toggleStackingEnergyPlot)
        {
            deactivateStackingEnergyPlot();
        }

        GenericManager atomManager = (GenericManager) UnityMolMain.getCurrentAtomManager();

        atomManager.ResetIMDSimulationPositions();

        GenericManager bondManager = (GenericManager) UnityMolMain.getCurrentBondManager();
        bondManager.ResetIMDSimulationPositions();
    }
}