Наследование: MonoBehaviour
Пример #1
0
        private void createTexture(int size)
        {
            VideoDriver drv = device.VideoDriver;

            Texture o = texture;

            texture = drv.AddTexture(new Dimension2Di(size), "tex");

            TexturePainter p = texture.Painter;

            p.Lock(TextureLockMode.WriteOnly);
            for (int i = 0; i < p.MipMapLevelHeight; i++)
            {
                p.SetLine(0, i, p.MipMapLevelWidth - 1, i, new Color(200, 200, 200));
            }
            p.Unlock(true);

            guiImage.Image = texture;
            sceneNodePainter.SetMaterialTexture(0, texture);

            if (o != null)
            {
                drv.RemoveTexture(o);
            }
        }
Пример #2
0
    void Start()
    {
        //Drawing to A texture
        texturePainter = new TexturePainter();

        GameObject plane = GameObject.FindGameObjectWithTag("Player");

        if (!enableTextureDrawer)
        {
            plane.SetActive(false);
        }
        plane.GetComponent <Renderer> ().material.mainTexture = texturePainter.texture;


        myslider = GameObject.Find("Slider").GetComponent <Slider>();

        symmetryDropDown = GameObject.Find("Dropdown").GetComponent <Dropdown>();
        List <System.String> options = new List <System.String> ();

        //Populate UI
        for (int i = 0; i < maxNumSymmetries; i++)
        {
            options.Add(i.ToString());
        }

        symmetryDropDown.AddOptions(options);

        vectorDrawer = this.GetComponent <VectorDrawer> ();
        //vectorDrawer.linePoints = linePoints;
        vectorDrawer.setNumberOfLines(numOfLineRenderers);
    }
Пример #3
0
 // Use this for initialization
 void Start()
 {
     this.arAPIHandler   = new ARAPIHandler();
     this.photosHandler  = new PhotosHandler();
     this.texturePainter = new TexturePainter(this.photosHandler);
     this.sizeHandler    = new SizeHandler(this.photosHandler);
     Debug.Log("photoNameText.text: " + this.photoNameText.text);
 }
 private void Awake()
 {
     if (instance != null)
     {
         Debug.Log("birden c*k texturepainter sahnede");
     }
     instance = this;
 }
Пример #5
0
    public void drawTexture(List <Vector3> drawPoints)
    {
        for (int j = 0; j < drawPoints.Count() - 1; j++)
        {
            int x1 = (int)ExtensionMethods.Remap(drawPoints[j].x, -470, 470, 0, textureWidth);
            int y1 = (int)ExtensionMethods.Remap(drawPoints[j].y, -300, 300, 0, textureHeight);

            int x2 = (int)ExtensionMethods.Remap(drawPoints[j + 1].x, -470, 470, 0, textureWidth);
            int y2 = (int)ExtensionMethods.Remap(drawPoints[j + 1].y, -300, 300, 0, textureHeight);


            TexturePainter.rasterizeBresenham(x1, y1, x2, y2, texture);
            //TexturePainter.plotLineAA(x1, y1, x2, y2, brushSize, texture);
        }
    }
Пример #6
0
    // Use this for initialization
    void Start()
    {
        painter           = TexturePainter.instance;
        painter.brushSize = 15;

        resetButton.onClick.AddListener(Reset);
        mainOptionsButton.onClick.AddListener(MainOptions);
        openSaveMenuButton.onClick.AddListener(SavePanel);
        loadPanelButton.onClick.AddListener(LoadPanel);
        mainMenuButton.onClick.AddListener(MainMenu);

        saveTrackButton.onClick.AddListener(SaveTrack);
        saveBackButton.onClick.AddListener(SaveBack);

        loadTrackButton.onClick.AddListener(LoadTrack);
        loadBackButton.onClick.AddListener(LoadBack);
    }
Пример #7
0
        bool OnEvent(Event e)
        {
            if (e.Type == EventType.Mouse)
            {
                int  x = e.Mouse.X;
                int  y = e.Mouse.Y;
                bool l = e.Mouse.IsLeftPressed();

                if (l && guiImage.AbsolutePosition.IsPointInside(new Vector2Di(x, y)))
                {
                    Vector2Di p = new Vector2Di(x, y) - guiImage.AbsolutePosition.UpperLeftCorner;

                    if (e.Mouse.Type == MouseEventType.Move)
                    {
                        TexturePainter t = texture.Painter;

                        if (p.X < texture.Size.Width &&
                            p.Y < texture.Size.Height &&
                            t.Lock(TextureLockMode.WriteOnly))
                        {
                            t.SetLine(oldMouseX, oldMouseY, p.X, p.Y, new Color(255, 0, 0));
                            t.Unlock(true);
                        }
                    }

                    oldMouseX = p.X;
                    oldMouseY = p.Y;

                    return(true);
                }
            }

            if (e.Type == EventType.GUI)
            {
                if (e.GUI.Type == GUIEventType.ElementClosed &&
                    e.GUI.Caller is GUIWindow)
                {
                    device.Close();
                    return(true);
                }

                if (e.GUI.Type == GUIEventType.ButtonClicked)
                {
                    if (e.GUI.Caller == guiSize128)
                    {
                        initGUI(128);
                        createTexture(128);
                        return(true);
                    }

                    if (e.GUI.Caller == guiSize256)
                    {
                        initGUI(256);
                        createTexture(256);
                        return(true);
                    }

                    if (e.GUI.Caller == guiSize512)
                    {
                        initGUI(512);
                        createTexture(512);
                        return(true);
                    }
                }
            }

            return(false);
        }
Пример #8
0
 public Tile(int screenX, int screenY, Dimension2Di screenDimension, VideoDriver driver)
 {
     ScreenPos      = new Vector2Di(screenX, screenY);
     Texture        = driver.AddTexture(screenDimension, string.Format("TileTexture({0},{1})", screenX, screenY));
     TexturePainter = Texture.Painter;
 }
 void Start()
 {
     Instance = this;
 }
Пример #10
0
 void Awake()
 {
     instance = this;
 }
Пример #11
0
        /// <summary>
        /// Called when user has uncovered a CardPair.
        /// </summary>
        private async void OnMessage_Received(CardPairUncoveredByPlayerMessage message)
        {
            // Define 'global' variables
            TexturePainter objVideoPainter = null;
            NamedOrGenericKey resVideoTextureFirstFrame = NamedOrGenericKey.Empty;
            NamedOrGenericKey resVideoTextureLastFrame = NamedOrGenericKey.Empty;

            // Get the link to the video file
            ResourceLink firstVideo =
                message.CardPair.PairData.ChildVideos.FirstOrDefault();
            if (firstVideo == null) { return; }

            // Attach the video texture to the scene
            Task startAnimationTask = null;
            await base.Scene.ManipulateSceneAsync((manipulator) =>
            {
                // Create the layer (if necessary)
                if (!manipulator.ContainsLayer(Constants.GFX_LAYER_VIDEO_FOREGROUND))
                {
                    SceneLayer bgLayer = manipulator.AddLayer(Constants.GFX_LAYER_VIDEO_FOREGROUND);
                    bgLayer.ClearDepthBufferBefreRendering = true;
                    manipulator.SetLayerOrderID(
                        bgLayer,
                        Constants.GFX_LAYER_VIDEO_FOREGROUND_ORDERID);
                }

                // Load the texture painter
                resVideoTextureFirstFrame = manipulator.AddResource(
                    () => new BitmapTextureResource(message.CardPair.PairData.FirstVideoFrame));
                objVideoPainter = new TexturePainter(resVideoTextureFirstFrame);
                objVideoPainter.Scaling = 0.6f;
                objVideoPainter.AccentuationFactor = 1f;
                objVideoPainter.Opacity = 0.0f;
                startAnimationTask = objVideoPainter.BuildAnimationSequence()
                    .Delay(300)
                    .WaitFinished()
                    .ScaleTo(1f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .ChangeOpacityTo(1f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .ApplyAsync();

                manipulator.Add(
                    objVideoPainter,
                    Constants.GFX_LAYER_VIDEO_FOREGROUND);
            });

            // Wait until start animation has finished
            await startAnimationTask;

            // Trigger start of video playing
            this.Messenger.Publish(new PlayMovieRequestMessage(firstVideo));

            // Change the content of the fullscreen texture to match the last video frame
            await Task.Delay(500);
            await base.Scene.ManipulateSceneAsync((manipulator) =>
            {
                manipulator.Remove(objVideoPainter);
                manipulator.RemoveResource(resVideoTextureFirstFrame);

                resVideoTextureLastFrame = manipulator.AddResource(
                    () => new BitmapTextureResource(message.CardPair.PairData.LastVideoFrame));
                objVideoPainter = new TexturePainter(resVideoTextureLastFrame);
                objVideoPainter.AccentuationFactor = 1f;

                manipulator.Add(
                    objVideoPainter,
                    Constants.GFX_LAYER_VIDEO_FOREGROUND);
            });

            // Wait for finished video rendering
            await this.Messenger.WaitForMessageAsync<PlayMovieFinishedMessage>();

            // Hide the video again
            await objVideoPainter.BuildAnimationSequence()
                .ScaleTo(1.4f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                .ChangeOpacityTo(0f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                .ApplyAsync();

            // Remove the texture painter
            await base.Scene.ManipulateSceneAsync((manipulator) =>
            {
                manipulator.Remove(objVideoPainter);
                manipulator.RemoveResource(resVideoTextureLastFrame);
            });
        }
Пример #12
0
        /// <summary>
        /// Shows the ending image if available.
        /// </summary>
        private async Task ShowEndingImage()
        {
            if (string.IsNullOrEmpty(m_levelData.EndingImage)) { return; }

            // Start media player for background music
            if (!string.IsNullOrEmpty(m_levelData.EndingMusic))
            {
                m_mediaPlayer = new MediaPlayerComponent();
                m_mediaPlayer.RestartWhenFinished = true;
                m_mediaPlayer.AudioVolume = 0f;
                m_mediaPlayer.OpenAndShowVideoFileAsync(m_levelData.EndingMusic)
                    .ContinueWith(async (givenTask) =>
                    {
                        while(m_mediaPlayer.AudioVolume < 1f)
                        {
                            m_mediaPlayer.AudioVolume = EngineMath.Clamp(
                                m_mediaPlayer.AudioVolume + 0.1f,
                                0f, 1f);
                            await Task.Delay(100);
                        }
                    })
                    .FireAndForget();
            }

            // Prepare main variables
            NamedOrGenericKey resEndingImage = NamedOrGenericKey.Empty;
            TexturePainter objVideoPainter = null;

            // Attach the video texture to the scene
            Task imageAnimationTask = null;
            await base.Scene.ManipulateSceneAsync((manipulator) =>
            {
                // Create the layer (if necessary)
                if (!manipulator.ContainsLayer(Constants.GFX_LAYER_VIDEO_FOREGROUND))
                {
                    SceneLayer bgLayer = manipulator.AddLayer(Constants.GFX_LAYER_VIDEO_FOREGROUND);
                    bgLayer.ClearDepthBufferBefreRendering = true;
                    manipulator.SetLayerOrderID(
                        bgLayer,
                        Constants.GFX_LAYER_VIDEO_FOREGROUND_ORDERID);
                }

                // Load the texture painter
                resEndingImage = manipulator.AddResource(
                    () => new StandardTextureResource(m_levelData.EndingImage));
                objVideoPainter = new TexturePainter(resEndingImage);
                objVideoPainter.Scaling = 0.6f;
                objVideoPainter.AccentuationFactor = 1f;
                objVideoPainter.Opacity = 0.0f;
                imageAnimationTask = objVideoPainter.BuildAnimationSequence()
                    .Delay(300)
                    .WaitFinished()
                    .ScaleTo(0.9f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .ChangeOpacityTo(1f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .WaitFinished()
                    .Delay(10000)
                    .WaitFinished()
                    .ScaleTo(1.5f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .ChangeOpacityTo(0f, TimeSpan.FromMilliseconds(Constants.FADE_INOUT_ANIM_TIME))
                    .ApplyAsync();

                manipulator.Add(
                    objVideoPainter,
                    Constants.GFX_LAYER_VIDEO_FOREGROUND);
            });

            // Close media-playing
            if(m_mediaPlayer != null)
            {
                imageAnimationTask.ContinueWith(async (givenTask) =>
                    {
                        while (m_mediaPlayer.AudioVolume > 0f)
                        {
                            m_mediaPlayer.AudioVolume = EngineMath.Clamp(
                                m_mediaPlayer.AudioVolume - 0.1f,
                                0f, 1f);
                            await Task.Delay(100);
                        }
                    })
                    .FireAndForget();
            }

            await imageAnimationTask;
        }
Пример #13
0
 void Awake()
 {
     singleton          = this;
     paintableLayerMask = 1 << LayerMask.NameToLayer(c_paintableLayer);
 }
Пример #14
0
			public Tile(int screenX, int screenY, Dimension2Di screenDimension, VideoDriver driver)
			{
				ScreenPos = new Vector2Di(screenX, screenY);
				Texture = driver.AddTexture(screenDimension, string.Format("TileTexture({0},{1})", screenX, screenY));
				TexturePainter = Texture.Painter;
			}