private void createImage()
    {
        MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.mediaId);
        if (mediaModel.image == null)
        {
            Log.Instance.Error("Imagem com id " + component.mediaId + " não existe.");
            return;
        }
        image = new GameObject();
        image.transform.parent = container.transform;
        image.name             = "image";
        image.AddComponent <Image>();
        if (mediaModel.image != null)
        {
            image.GetComponent <Image>().sprite = mediaModel.image[0];
        }
        RectTransform recTransform = image.GetComponent <RectTransform>();

        //recTransform.pivot = Vector2.up;
        recTransform.localPosition = new Vector3(0, 0, 0);
        if ((component.objHeight != 0) && (component.objWidth != 0))
        {
            size = new Vector2(component.objWidth, component.objHeight);
        }
        else
        {
            size = new Vector2(mediaModel.image[0].rect.width, mediaModel.image[0].rect.height);
        }
        recTransform.sizeDelta  = size;
        recTransform.localScale = Vector3.one;
    }
Example #2
0
 public void Update()
 {
     MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.mediaId);
     if (mediaModel.image != null)
     {
         if (Time.time >= initTimer + component.config.animationTime)
         {
             posAnimation += 1;
         }
         if (posAnimation >= mediaModel.image.Length)
         {
             if (component.config.loop)
             {
                 startAnimation();
             }
             Transform parentView = container.transform;
             while (parentView.parent.GetComponent <Canvas>() == null)
             {
                 parentView = parentView.parent;
             }
             parentView.gameObject.BroadcastMessage("AnimationFinish", container.name, SendMessageOptions.DontRequireReceiver);
         }
         //Debug.Log("posAnimation = " + posAnimation + " - lenght = " + mediaModel.image.Length);
         if (mediaModel.image[posAnimation] == null)
         {
             Debug.Log("animacao nula = " + posAnimation);
         }
         image.GetComponent <Image>().sprite = mediaModel.image[posAnimation];
     }
 }
Example #3
0
    private void createImage()
    {
        image = new GameObject();
        image.transform.parent = container.transform;
        image.name             = "image";
        //gameObject.transform.position = position;
        image.AddComponent <Image>();
        MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.mediaId);
        if (mediaModel.image != null)
        {
            image.GetComponent <Image>().sprite = mediaModel.image[0];
        }
        RectTransform recTransform = image.GetComponent <RectTransform>();

        recTransform.pivot         = new Vector2(0.5f, 0.5f);
        recTransform.localPosition = new Vector3(0, 0, 0);
        if ((component.objHeight != 0) && (component.objWidth != 0))
        {
            size = new Vector2(component.objWidth, component.objHeight);
        }
        else
        {
            size = new Vector2(mediaModel.image[0].rect.width, mediaModel.image[0].rect.height);
        }
        recTransform.sizeDelta = size;
        startAnimation();
    }
Example #4
0
    private void createButton()
    {
        button = new GameObject();
        button.transform.parent = container.transform;
        button.name             = "button";
        radioButtonMode         = component.config.radioButtonMode;
        button.AddComponent <Button>();
        button.AddComponent <Image>();
        ButtonEvent buttonEvent = button.AddComponent <ButtonEvent>();

        buttonEvent.myDelegateDown       = onMouseDown;
        buttonEvent.myDelegateUp         = onMouseUp;
        buttonEvent.myDelegateDeactivate = deactivate;
        MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.imageArray[0].id);
        if (mediaModel.image != null)
        {
            button.GetComponent <Image>().sprite = mediaModel.image[0];
            arraySprite[0] = mediaModel.image[0];
        }
        if (component.imageArray.Length > 1)
        {
            mediaModel = MediaLoader.instance.getMediaById(component.imageArray[1].id);
            Debug.Log("mediaModel = " + mediaModel.id + " - " + mediaModel.image);
            if (mediaModel.image != null)
            {
                arraySprite[1] = mediaModel.image[0];
            }
        }
        RectTransform recTransform = button.GetComponent <RectTransform>();

        recTransform.pivot         = Vector2.up;
        recTransform.localPosition = new Vector3(0, 0, 0);
        if ((component.objHeight != 0) && (component.objWidth != 0))
        {
            size = new Vector2(component.objWidth, component.objHeight);
        }
        else
        {
            size = new Vector2(arraySprite[0].rect.width, arraySprite[0].rect.height);
        }
        recTransform.sizeDelta = size;
        newScale       = recTransform.localScale;
        buttonPosition = newPosition = recTransform.localPosition;
    }
    private void createImage()
    {
        //gameObject.transform.position = position;
        RectTransform recTransform = container.AddComponent <RectTransform>();
        //recTransform.pivot = Vector2.up;
        Vector2 size = Vector2.zero;

        recTransform.localScale = Vector3.one;
        if (component.config.maskType.ToLower() == "mask")
        {
            container.AddComponent <Image>();
            MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.mediaId);
            if (mediaModel.image != null)
            {
                container.GetComponent <Image>().sprite = mediaModel.image[0];
            }
            if ((component.objHeight != 0) && (component.objWidth != 0))
            {
                size = new Vector2(component.objWidth, component.objHeight);
            }
            else
            {
                size = new Vector2(mediaModel.image[0].rect.width, mediaModel.image[0].rect.height);
            }
            container.AddComponent <Mask>();
        }
        else if (component.config.maskType.ToLower() == "rectmask")
        {
            if ((component.objHeight != 0) && (component.objWidth != 0))
            {
                size = new Vector2(component.objWidth, component.objHeight);
            }
            recTransform.pivot = new Vector2(0, 0.5f);
            container.AddComponent <RectMask2D>();
        }
        else
        {
            container.AddComponent <RectMask2D>();
        }
        recTransform.sizeDelta = size;
    }
    private void createSlider()
    {
        GameObject sliderGO = new GameObject();

        sliderGO.transform.parent = container.transform;
        sliderGO.name             = "Slider";

        // add rect transform
        RectTransform sliderRect = sliderGO.AddComponent <RectTransform>();

        sliderRect.position  = Vector3.zero;
        sliderRect.sizeDelta = new Vector2(component.objWidth, component.objHeight);
        sliderRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderRect.pivot     = new Vector2(0.5f, 0.5f);

        // add slider component
        Slider sliderComponent = sliderGO.AddComponent <Slider>();

        sliderComponent.minValue = 0;
        sliderComponent.maxValue = 255;

        // create background
        GameObject sliderBackground = new GameObject();

        sliderBackground.name             = "Background";
        sliderBackground.transform.parent = sliderGO.transform;
        RectTransform sliderBackRect = sliderBackground.AddComponent <RectTransform>();

        sliderBackRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderBackRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderBackRect.pivot     = new Vector2(0.5f, 0.5f);
        Image sliderBackImage = sliderBackground.AddComponent <Image>();

        MediaLoader.MediaModel mediaModel = MediaLoader.instance.getMediaById(component.imageArray[0].id);
        if (mediaModel.image != null)
        {
            sliderBackImage.sprite   = mediaModel.image[0];
            sliderBackRect.sizeDelta = new Vector2(mediaModel.image[0].rect.width, mediaModel.image[0].rect.height);
        }

        // create fill area
        GameObject sliderFillArea = new GameObject();

        sliderFillArea.name             = "Fill Area";
        sliderFillArea.transform.parent = sliderGO.transform;
        RectTransform sliderFillAreaRect = sliderFillArea.AddComponent <RectTransform>();

        sliderFillAreaRect.position  = Vector3.zero;
        sliderFillAreaRect.sizeDelta = Vector2.one;
        sliderFillAreaRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderFillAreaRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderFillAreaRect.pivot     = Vector2.zero;

        // create Fill
        GameObject sliderFill = new GameObject();

        sliderFill.name             = "Fill";
        sliderFill.transform.parent = sliderFillArea.transform;
        RectTransform sliderFillRect = sliderFill.AddComponent <RectTransform>();

        sliderFillRect.position  = Vector3.zero;
        sliderFillRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderFillRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderFillRect.pivot     = new Vector2(0.5f, 0.5f);
        sliderFillRect.sizeDelta = new Vector2(296f, 50);
        Image sliderFillImage = sliderFill.AddComponent <Image>();

        mediaModel = MediaLoader.instance.getMediaById(component.imageArray[1].id);
        if (mediaModel.image != null)
        {
            sliderFillImage.sprite = mediaModel.image[0];
        }
        sliderFillImage.type           = Image.Type.Filled;
        sliderFillImage.fillMethod     = Image.FillMethod.Horizontal;
        sliderFillImage.fillOrigin     = 0;
        sliderFillImage.preserveAspect = true;
        sliderComponent.fillRect       = sliderFillRect;

        // create handle slide area
        GameObject sliderHandleArea = new GameObject();

        sliderHandleArea.name             = "Handle Slide Area";
        sliderHandleArea.transform.parent = sliderGO.transform;
        RectTransform sliderHandleAreaRect = sliderHandleArea.AddComponent <RectTransform>();

        sliderHandleAreaRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderHandleAreaRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderHandleAreaRect.pivot     = new Vector2(0.5f, 0.5f);
        sliderHandleAreaRect.sizeDelta = new Vector2(236.6f, 50);

        // create handle
        GameObject sliderHandle = new GameObject();

        sliderHandle.name             = "Handle";
        sliderHandle.transform.parent = sliderHandleArea.transform;
        RectTransform sliderHandleRect = sliderHandle.AddComponent <RectTransform>();

        sliderHandleRect.anchorMin = new Vector2(0.5f, 0.5f);
        sliderHandleRect.anchorMax = new Vector2(0.5f, 0.5f);
        sliderHandleRect.pivot     = new Vector2(0.5f, 0.5f);
        Image sliderHandleImage = sliderHandle.AddComponent <Image>();

        mediaModel = MediaLoader.instance.getMediaById(component.imageArray[2].id);
        if (mediaModel.image != null)
        {
            sliderHandleImage.sprite   = mediaModel.image[0];
            sliderHandleRect.sizeDelta = new Vector2(mediaModel.image[0].rect.width, mediaModel.image[0].rect.height);
        }
        sliderHandleImage.preserveAspect = true;
        sliderComponent.handleRect       = sliderHandleRect;
        sliderComponent.targetGraphic    = sliderHandleImage;

        sliderGO.transform.localPosition = Vector3.zero;
    }