public void StoreResolutionY()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.RESOLUTION_Y);

        args.Value = ResolutionYField.text;
        OnStoreParameter(this, args);
    }
    public void StoreRandomizationSeed()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.RANDOMIZATION_SEED);

        args.Value = int.Parse(RandomizationField.text);
        OnStoreParameter(this, args);
    }
    public void StoreColorImage()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.COLOR_IMAGE);

        args.Value = ColorImageToggle.isOn;
        OnStoreParameter(this, args);
    }
    public void StoreTargetFolder()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.TARGET_FOLDER);

        args.Value = TargetFolderField.text;
        OnStoreParameter(this, args);
    }
    public void StoreDepthImage()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.DEPTH_IMAGE);

        args.Value = DepthImageToggle.isOn;
        OnStoreParameter(this, args);
    }
    public void StoreSegmentationImage()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.SEGMENTATION_IMAGE);

        args.Value = SegmentationImageToggle.isOn;
        OnStoreParameter(this, args);
    }
    public void StoreOnlyFullyCoveredObjects()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.ONLY_FULLY_COVERED_OBJECTS);

        args.Value = OnlyFullyCoveredObjectsToggle.isOn;
        OnStoreParameter(this, args);
    }
    public void StoreAmountOfImages()
    {
        var args = new StoreParameterEventArgs(Constants.GeneralParameter.AMOUNT_OF_IMAGES);

        args.Value = AmountOfImagesField.text;
        OnStoreParameter(this, args);
    }
Example #9
0
    public void ParameterValueChanged()
    {
        Vector3 scale = new Vector3(float.Parse(valueX.text), float.Parse(valueY.text), float.Parse(valueZ.text));
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);

        args.Value = scale;
        OnParameterValueChanged(this, args);
    }
Example #10
0
    public void ParameterValueChanged()
    {
        Vector3 rotation             = new Vector3(valueX.text.Equals("") ? 0 : float.Parse(valueX.text), valueY.text.Equals("") ? 0 : float.Parse(valueY.text), valueZ.text.Equals("") ? 0 : float.Parse(valueZ.text));
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);

        args.Value = rotation;
        OnParameterValueChanged(this, args);
    }
Example #11
0
    public void ParameterValueChanged()
    {
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);
        string text = AngleInputField.text.Replace(".", ",");

        args.Value = float.Parse(AngleInputField.text);
        OnParameterValueChanged(this, args);
    }
 private void SceneObjectValueChanged(object sender, StoreParameterEventArgs e)
 {
     foreach (var parameterModel in model.Parameter)
     {
         if (parameterModel.ParameterType == e.ParameterType)
         {
             parameterModel.StoreValue(e);
         }
     }
 }
Example #13
0
    public void ParameterValueChanged()
    {
        Color newColor = new Color(float.Parse(valueR.text) / 256, float.Parse(valueG.text) / 256, float.Parse(valueB.text) / 256);

        ColorField.color = newColor;
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);

        args.Value = newColor;
        OnParameterValueChanged(this, args);
    }
    public void ParameterValueChanged(object sender, StoreParameterEventArgs e)
    {
        foreach (var parameterModel in model.Parameter)
        {
            if (parameterModel.ParameterType == e.ParameterType)
            {
                parameterModel.StoreAndApplyValueOnSceneObject(e);

                if (e.ParameterType == Constants.SceneObjectParameter.POSITION)
                {
                    OnUpdateArrow(this, EventArgs.Empty);
                }
            }
        }
    }
    public void ParameterValueChanged()
    {
        Color newColor = new Color(float.Parse(valueR.text) / 256, float.Parse(valueG.text) / 256, float.Parse(valueB.text) / 256);
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);

        args.Value = newColor;
        OnParameterValueChanged(this, args);

        /*
         * Color color;
         * if ((HexField.text.Length == 7 || HexField.text.Length == 9) && ColorUtility.TryParseHtmlString(HexField.text, out color))
         * {
         *  HexField.image.color = Color.white;
         *  ColorField.GetComponent<Image>().color = color;
         *  StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);
         *  args.Value = color;
         *  OnParameterValueChanged(this, args);
         * }
         * else
         * {
         *  HexField.image.color = new Color(255, 0, 0, 0.2f);
         * }*/
    }
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Color = (Color)args.Value;
 }
 public override void StoreAndApplyValueOnSceneObject(StoreParameterEventArgs args)
 {
     StoreValue(args);
     OnUpdateSceneObjectView(this, args);
 }
Example #18
0
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Scale = (Vector3)args.Value;
 }
    public void StoreParameter(object sender, StoreParameterEventArgs e)
    {
        switch (e.ParameterType)
        {
        case Constants.GeneralParameter.TARGET_FOLDER:
        {
            model.TargetFolder = (string)e.Value;
            break;
        }

        case Constants.GeneralParameter.RANDOMIZATION_SEED:
        {
            ApplicationManager.instance.GlobalSettingsModel.GeneralParameterModel.RandomizationSeed = (int.Parse(e.Value.ToString()));
            break;
        }

        case Constants.GeneralParameter.AMOUNT_OF_IMAGES:
        {
            model.AmountOfImages = int.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.RESOLUTION_X:
        {
            model.ResolutionX = int.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.RESOLUTION_Y:
        {
            model.ResolutionY = int.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.COLOR_IMAGE:
        {
            model.ColorPictures = bool.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.DEPTH_IMAGE:
        {
            model.DepthPictures = bool.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.SEGMENTATION_IMAGE:
        {
            model.SegmentationPicture = bool.Parse(e.Value.ToString());
            break;
        }

        case Constants.GeneralParameter.ONLY_FULLY_COVERED_OBJECTS:
        {
            model.OnlyFullyCoveredObjects = bool.Parse(e.Value.ToString());
            break;
        }

        default:
            Debug.LogError("GeneralParameterController -> StoreParamter() : Parameter not defined: " + e.ParameterType);
            break;
        }
        ;
    }
Example #20
0
    public void ParameterValueChanged()
    {
        StoreParameterEventArgs args = new StoreParameterEventArgs(ParameterType);

        OnParameterValueChanged(this, args);
    }
Example #21
0
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Position = (Vector3)args.Value;
 }
Example #22
0
    private void Update()
    {
        //Item selection
        if (state == State.Idle || state == State.ItemSelection)
        {
            if (Input.GetMouseButtonUp(0) && !IsMouseOverUI())
            {
                RaycastHit hit;
                Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out hit, Mathf.Infinity, LayerMask.GetMask("SceneObject", "Visualization")))
                {
                    SceneObjectSelectedEventArgs args = new SceneObjectSelectedEventArgs();
                    args.Selection = hit.transform.gameObject;

                    OnSceneObjectSelected(this, args);
                }
                else
                {
                    if (Selection != null)
                    {
                        OnSceneObjectDeselected();
                    }
                }
            }
        }

        //Delete selected sceneobject with DeleteKey
        if (state == State.ItemSelection)
        {
            if (Input.GetKeyUp(KeyCode.Delete))
            {
                ISceneObjectView view = Selection.GetComponent <ISceneObjectView>();
                if (view != null)
                {
                    SceneObjectSelectedEventArgs args = new SceneObjectSelectedEventArgs();
                    view.DeleteSceneObject();
                    args.Selection = Selection;
                    OnHideParameter(this, args);
                    Selection.GetComponent <SceneObjectView>().DestoyController();
                }
                else
                {
                    OnDefaultSunDeleted();
                }
                Destroy(Selection);
                Arrow.SetActive(false);
                state     = State.Idle;
                Selection = null;
            }
        }

        //During texture placement
        if (state == State.TexturePlacement)
        {
            if (!IsMouseOverUI())
            {
                RaycastHit hit;
                Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out hit, Mathf.Infinity, LayerMask.GetMask("SceneObject")))
                {
                    Selection.transform.position = hit.point;
                    if (Input.GetMouseButtonUp(0))
                    {
                        ISceneObjectView view = hit.transform.GetComponent <ISceneObjectView>();
                        if (view != null)
                        {
                            StoreParameterEventArgs args = new StoreParameterEventArgs(Constants.SceneObjectParameter.TEXTURE);
                            args.Value = Selection.GetComponent <Renderer>().material;
                            view.ParameterValueChanged(this, args);
                        }
                    }
                }
                else
                {
                    Vector3 pos = Input.mousePosition;
                    pos.z = objectDistance;

                    Selection.transform.position = Camera.main.ScreenToWorldPoint(pos);
                }
            }

            if (Input.GetMouseButtonUp(1))
            {
                Destroy(Selection);
                Selection = null;
                state     = State.Idle;
            }
        }

        //During moving with Arrow
        if (state == State.SelectionMovement)
        {
            if (Input.GetMouseButtonUp(0))
            {
                Direction = Vector3.zero;
                state     = State.ItemSelection;
            }
            else
            {
                Vector2 diff          = Input.mousePosition - lastMousePosition;
                float   movementSpeed = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) ? 0.1f : 0.5f;
                Selection.transform.position += Direction * movementSpeed * (diff.x + diff.y);
                lastMousePosition             = Input.mousePosition;
                Selection.GetComponent <ISceneObjectView>().SceneObjectValueChanged(Constants.SceneObjectParameter.POSITION, Selection.transform.position);
                MoveArrow();
            }
        }

        //During placement of an item
        if (Selection != null && state == State.ItemPlacement)
        {
            //Dont show item above UI
            if (!IsMouseOverUI())
            {
                RaycastHit hit;
                Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out hit, Mathf.Infinity, LayerMask.GetMask("SceneObject", "Visualization")))
                {
                    if (hit.transform.tag != "Arrow")
                    {
                        Selection.transform.position = hit.point;
                    }
                }
                else
                {
                    Vector3 pos = Input.mousePosition;
                    pos.z = objectDistance;

                    Selection.transform.position = Camera.main.ScreenToWorldPoint(pos);
                }
                MoveArrow();

                Selection.GetComponent <ISceneObjectView>().SceneObjectValueChanged(Constants.SceneObjectParameter.POSITION, Selection.transform.position);

                if (Input.GetMouseButtonUp(0))
                {
                    OnPlaceItem(this, EventArgs.Empty);
                }
                if (Input.GetMouseButtonUp(1))
                {
                    Selection.GetComponent <ISceneObjectView>().DeleteSceneObject();
                    Selection.GetComponent <ISceneObjectView>().DestoyController();
                    Destroy(Selection);
                    Arrow.SetActive(false);
                    Selection = null;
                    state     = State.Idle;
                }
            }
        }
    }
Example #23
0
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Material = (Material)args.Value;
 }
Example #24
0
    public override void StoreValue(StoreParameterEventArgs args)
    {
        Vector3 rotation = (Vector3)args.Value;

        Rotation = rotation;
    }
Example #25
0
 //Store the given value into the model and refresh
 public abstract void StoreAndApplyValueOnSceneObject(StoreParameterEventArgs args);
Example #26
0
 //store the given value in the specific value of the model
 public abstract void StoreValue(StoreParameterEventArgs args);
Example #27
0
 public void ParameterValueChanged(object sender, StoreParameterEventArgs e)
 {
     OnParameterValueChanged(this, e);
 }
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Intensity = (float)args.Value;
 }
Example #29
0
 public override void StoreValue(StoreParameterEventArgs args)
 {
     Range = (float)args.Value;
 }