コード例 #1
0
    // Start is called before the first frame update
    IEnumerator AskDetection()
    {
        yield return(new WaitForEndOfFrame());

        RenderTexture renderTexture = RenderTexture.GetTemporary(Screen.width, Screen.height, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default, 1);

        ScreenCapture.CaptureScreenshotIntoRenderTexture(renderTexture);
        RenderTexture.active = renderTexture;


        txtDebug.text = "we bello hguaglio";
        ScreenshotTexture.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
        ScreenshotTexture.Apply();

        byte[] img = ScreenshotTexture.EncodeToJPG();


        string url = baseurl + "predict/synth1";
        List <IMultipartFormSection> data = new List <IMultipartFormSection>();

        data.Add(new MultipartFormFileSection("image", img, "img.jpg", "image/jpeg"));
        UnityWebRequest request = UnityWebRequest.Post(url, data);

        yield return(request.SendWebRequest());

        if (request.isNetworkError || request.isHttpError)
        {
            Debug.LogError(request.error);
            yield break;
        }
        JSONNode response = JSON.Parse(request.downloadHandler.text);

        txtDebug.text = response;
    }
コード例 #2
0
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.A))
        {
            ScreenCapture.CaptureScreenshot($"{Application.dataPath}/Resources/Screenshoot.jpg");
            m_ShortShoot = Resources.Load <Texture>("ScreenShoot");
        }

        if (Input.GetKeyDown(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.S))
        {
            m_ShortShoot = ScreenCapture.CaptureScreenshotAsTexture(0);
        }

        if (Input.GetKeyDown(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.D))
        {
            RenderTexture renderTexture = new RenderTexture(720, 1280, 0);
            ScreenCapture.CaptureScreenshotIntoRenderTexture(renderTexture);
            m_ShortShoot = renderTexture;
        }

        if (Input.GetKeyDown(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.F))
        {
            StartCoroutine(TScreenCapture());
        }
    }
コード例 #3
0
ファイル: Recorder.cs プロジェクト: twopmstudios/Moments
        IEnumerator RecordFrame()
        {
            yield return(new WaitForEndOfFrame());

            // Limit the amount of frames stored in memory
            if (m_Frames.Count >= m_MaxFrameCount)
            {
                m_RecycledRenderTexture = m_Frames.Dequeue();
            }

            m_Time -= m_TimePerFrame;

            // Frame data
            RenderTexture rt = m_RecycledRenderTexture;

            m_RecycledRenderTexture = null;

            if (rt == null)
            {
                rt            = new RenderTexture(m_Width, m_Height, 0, RenderTextureFormat.ARGB32);
                rt.wrapMode   = TextureWrapMode.Clamp;
                rt.filterMode = FilterMode.Bilinear;
                rt.anisoLevel = 0;
            }

            ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
            m_Frames.Enqueue(rt);
        }
コード例 #4
0
        public IEnumerator UpdateScreenshotTexture()
        {
            yield return(new WaitForEndOfFrame());

            ScreenCapture.CaptureScreenshotIntoRenderTexture(_renderTexture);
            ScreenshotTexture.ReadPixels(new Rect(0, 0, _renderTexture.width, _renderTexture.height), 0, 0);
            ScreenshotTexture.Apply();

            byte[] bytes    = ScreenshotTexture.EncodeToPNG();
            string filename = ScreenShotName(m_ssRes.x, m_ssRes.y);

            if (System.IO.Directory.Exists(Application.dataPath + "/screenshots"))
            {
                System.IO.File.WriteAllBytes(filename, bytes);
                Debug.Log(string.Format("Took screenshot to: {0}", filename));
                takeHiResShot = false;
            }
            else
            {
                System.IO.Directory.CreateDirectory(Application.dataPath + "/screenshots");
                System.IO.File.WriteAllBytes(filename, bytes);
                Debug.Log(string.Format("Took screenshot to: {0}", filename));
                takeHiResShot = false;
            }
        }
コード例 #5
0
        public int CaptureScreen(int id)
        {
            if (commandBuffer == null)
            {
                commandBuffer      = new CommandBuffer();
                commandBuffer.name = "ScreenCapture";
            }
            commandBuffer.Clear();

            for (int i = 0; i < FRAME_NUM; ++i)
            {
                if (!IsAvailable(i))
                {
                    continue;
                }
                frames[i].id = id;
                this.WriteToTagInfo(id, 0);
                this.WriteToTagInfoShort(Screen.width, 8);
                this.WriteToTagInfoShort(Screen.height, 10);
                Profiler.EmitFrameMetaData(ScreenShotToProfiler.MetadataGuid, ScreenShotToProfiler.InfoTag, tagInfo);
                var rt = RenderTexture.GetTemporary(Screen.width, Screen.height, 0, RenderTextureFormat.ARGB32);
                ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
                commandBuffer.BeginSample(CAPTURE_CMD_SAMPLE);
                commandBuffer.Blit(rt, frames[i].renderTexture);
                commandBuffer.EndSample(CAPTURE_CMD_SAMPLE);
                Graphics.ExecuteCommandBuffer(commandBuffer);
                RenderTexture.ReleaseTemporary(rt);
                commandBuffer.Clear();
                return(i);
            }
            return(-1);
        }
コード例 #6
0
        protected internal override void NewFrameReady(RecordingSession session)
        {
            Profiler.BeginSample("GameViewInput.NewFrameReady");
            ScreenCapture.CaptureScreenshotIntoRenderTexture(m_CaptureTexture);

            // Force opaque alpha channel and perform vertical flip if necessary
            MakeFullyOpaqueAndPerformVFlip(OutputRenderTexture);
            Profiler.EndSample();
        }
コード例 #7
0
ファイル: GameViewInput.cs プロジェクト: Reflex21/Moba
        public override void NewFrameReady(RecordingSession session)
        {
            Profiler.BeginSample("GameViewInput.NewFrameReady");
#if UNITY_2019_1_OR_NEWER
            ScreenCapture.CaptureScreenshotIntoRenderTexture(m_CaptureTexture);
            m_VFlipper?.Flip(m_CaptureTexture);
#else
            readbackTexture = ScreenCapture.CaptureScreenshotAsTexture();
#endif
            Profiler.EndSample();
        }
コード例 #8
0
        protected internal override void NewFrameReady(RecordingSession session)
        {
            Profiler.BeginSample("GameViewInput.NewFrameReady");
#if UNITY_2019_1_OR_NEWER
            ScreenCapture.CaptureScreenshotIntoRenderTexture(m_CaptureTexture);
            var  movieRecorderSettings = session.settings as MovieRecorderSettings;
            bool needToFlip            = scSettings.FlipFinalOutput;
            if (movieRecorderSettings != null)
            {
                bool encoderAlreadyFlips = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected].PerformsVerticalFlip;
                needToFlip &= encoderAlreadyFlips;
            }

            if (needToFlip)
            {
                OutputRenderTexture = m_VFlipper?.Flip(m_CaptureTexture);
            }

            // Force opaque alpha channel
            MakeFullyOpaque(OutputRenderTexture);
#else
            ReadbackTexture = ScreenCapture.CaptureScreenshotAsTexture();
            var movieRecorderSettings = session.settings as MovieRecorderSettings;
            if (movieRecorderSettings != null)
            {
                var currEncoder    = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected];
                var requiredFormat = currEncoder.GetTextureFormat(movieRecorderSettings);
                var isGameView     = movieRecorderSettings.ImageInputSettings is GameViewInputSettings;
                if (!currEncoder.PerformsVerticalFlip)
                {
                    ReadbackTexture = UnityHelpers.FlipTextureVertically(ReadbackTexture, movieRecorderSettings.CaptureAlpha);
                }
                if (requiredFormat != ReadbackTexture.format)
                {
                    if (requiredFormat == TextureFormat.RGB24 && ReadbackTexture.format == TextureFormat.RGBA32)
                    {
                        ReadbackTexture = UnityHelpers.RGBA32_to_RGB24(ReadbackTexture);
                    }
                    else
                    {
                        throw new Exception($"Unexpected conversion requested: from {ReadbackTexture.format} to {requiredFormat}.");
                    }
                }
            }

            // Force opaque alpha channel
            MakeFullyOpaque(ReadbackTexture);
#endif
            Profiler.EndSample();
        }
コード例 #9
0
    IEnumerator Start()
    {
        while (true)
        {
            yield return(new WaitForSeconds(1));

            yield return(new WaitForEndOfFrame());

            var rt = RenderTexture.GetTemporary(Screen.width, Screen.height, 0);
            ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
            AsyncGPUReadback.Request(rt, 0, TextureFormat.RGBA32, OnCompleteReadback);
            RenderTexture.ReleaseTemporary(rt);
        }
    }
コード例 #10
0
ファイル: SnapPhoto.cs プロジェクト: ash-chin/wtf
    IEnumerator SnapShot()
    {
        /*
         * This is the function that takes the photo. Turns the screenshot into
         * a texture that is then applied to the RawImage object.
         * NOTE! It is very important that thePhoto is disabled immediately after
         * because then this function will keep getting called as a coroutine and
         * it will basically turn into a horrible video feed lol
         *
         * The texture object is destroyed when the game is turned off via the
         * OnDisable() method inside Player_Space_Ship_Movement.cs.
         * Again, very important unless you like memory leaks.
         */
        yield return(new WaitForEndOfFrame());

        if (numPhotos == maxPhotos)
        {
            DebugText.text = "Out of Room!";
            //galleryCanvas.SetActive(false);
            galleryCanvas.enabled = false;
            reticleCanvas.SetActive(true);
            nameCanvas.SetActive(true);
            StopCoroutine(SnapShot());
            yield break;
        }

        thePhoto         = photoGallery[i];
        thePhoto.enabled = true;
        renderTexture    = photoTextures[i];

        renderTexture = new RenderTexture(Screen.width, Screen.height, 24, RenderTextureFormat.DefaultHDR);
        ScreenCapture.CaptureScreenshotIntoRenderTexture(renderTexture);
        thePhoto.texture = renderTexture;
        thePhoto.enabled = false;
        reticleCanvas.SetActive(true);
        nameCanvas.SetActive(true);

        i++;
        numPhotos++;

        galleryCanvas.enabled = false;
        //galleryCanvas.SetActive(false);

        /*
         * Texture2D texture = ScreenCapture.CaptureScreenshotAsTexture();
         * thePhoto.texture = texture;
         * thePhoto.enabled = false;
         */
    }
コード例 #11
0
        IEnumerator RecordScreenFrame()
        {
            while (true)
            {
                yield return(new WaitForEndOfFrame());

                if (!connections.Any() || m_sendTexture == null || !m_sendTexture.IsCreated())
                {
                    continue;
                }

                ScreenCapture.CaptureScreenshotIntoRenderTexture(m_screenTexture);
                Graphics.Blit(m_screenTexture, m_sendTexture);
            }
        }
コード例 #12
0
    System.Collections.IEnumerator Start()
    {
        InitSendInstance();
        InitConverter();

        for (var eof = new WaitForEndOfFrame(); true;)
        {
            // Wait for the end of the frame.
            yield return(eof);

            // Request chain: Capture -> Convert -> Readback
            ScreenCapture.CaptureScreenshotIntoRenderTexture(_capture);
            RunConversion();
            AsyncGPUReadback.Request(_converted, OnCompleteReadback);
        }
    }
    public void UpdateScreenshotTexture(bool grayscale)
    {
        RenderTexture transformedRenderTexture = null;
        RenderTexture renderTexture            = RenderTexture.GetTemporary(
            Screen.width,
            Screen.height,
            24,
            RenderTextureFormat.ARGB32,
            RenderTextureReadWrite.Default,
            1);

        try
        {
            ScreenCapture.CaptureScreenshotIntoRenderTexture(renderTexture);
            transformedRenderTexture = RenderTexture.GetTemporary(
                ScreenshotTexture.width,
                ScreenshotTexture.height,
                24,
                RenderTextureFormat.ARGB32,
                RenderTextureReadWrite.Default,
                1);
            Graphics.Blit(
                renderTexture,
                transformedRenderTexture,
                new Vector2(1.0f, -1.0f),
                new Vector2(0.0f, 1.0f));
            RenderTexture.active = transformedRenderTexture;
            ScreenshotTexture.ReadPixels(
                new Rect(0, 0, ScreenshotTexture.width, ScreenshotTexture.height),
                0, 0);
        }
        catch (Exception e)
        {
            Debug.Log("Exception: " + e);
        }
        finally
        {
            RenderTexture.active = null;
            RenderTexture.ReleaseTemporary(renderTexture);
            if (transformedRenderTexture != null)
            {
                RenderTexture.ReleaseTemporary(transformedRenderTexture);
            }
        }

        ScreenshotTexture.Apply();
    }
コード例 #14
0
        private IEnumerator CaptureScreen()
        {
            yield return(new WaitForEndOfFrame());

            int rtWidth  = Screen.width;
            int rtHeight = Screen.height;

            if (previousFrameRT == null || previousFrameRT.width != rtWidth || previousFrameRT.height != rtHeight)
            {
                if (previousFrameRT != null)
                {
                    Destroy(previousFrameRT);
                }
                previousFrameRT = new RenderTexture(rtWidth, rtHeight, 0);
            }
            ScreenCapture.CaptureScreenshotIntoRenderTexture(previousFrameRT);
        }
コード例 #15
0
        void Update()
        {
            // GameView capture mode
            if (_captureMethod == CaptureMethod.GameView)
            {
                PrepareBuffer(Screen.width, Screen.height);
                var temp = RenderTexture.GetTemporary(Screen.width, Screen.height, 0);
                ScreenCapture.CaptureScreenshotIntoRenderTexture(temp);
                Blitter.BlitVFlip(_resources, temp, _buffer, _keepAlpha);
                RenderTexture.ReleaseTemporary(temp);
            }

            // Texture capture mode
            if (_captureMethod == CaptureMethod.Texture)
            {
                if (_sourceTexture == null)
                {
                    return;
                }
                PrepareBuffer(_sourceTexture.width, _sourceTexture.height);
                Blitter.Blit(_resources, _sourceTexture, _buffer, _keepAlpha);
            }

            // Camera capture mode
            if (_captureMethod == CaptureMethod.Camera)
            {
                PrepareCameraCapture(_sourceCamera);
                if (_sourceCamera == null)
                {
                    return;
                }
                PrepareBuffer(_sourceCamera.pixelWidth, _sourceCamera.pixelHeight);
            }

            // Sender lazy initialization
            if (_sender == null)
            {
                _sender = new Sender(_spoutName, _buffer);
            }

            // Sender plugin-side update
            _sender.Update();
        }
コード例 #16
0
        System.Collections.IEnumerator CaptureCoroutine()
        {
            for (var eof = new WaitForEndOfFrame(); true;)
            {
                // Wait for the end of the frame.
                yield return(eof);

                PrepareSenderObjects();

                // Texture capture method
                if (captureMethod == CaptureMethod.Texture && sourceTexture != null)
                {
                    var(w, h) = (sourceTexture.width, sourceTexture.height);

                    // Pixel format conversion
                    var buffer = _converter.Encode(sourceTexture, keepAlpha, true);

                    // Readback entry allocation and request
                    _pool.NewEntry(w, h, keepAlpha, metadata)
                    .RequestReadback(buffer, _onReadback);
                }

                // Game View capture method
                if (captureMethod == CaptureMethod.GameView)
                {
                    // Game View screen capture with a temporary RT
                    var(w, h) = (Screen.width, Screen.height);
                    var tempRT = RenderTexture.GetTemporary(w, h, 0);
                    ScreenCapture.CaptureScreenshotIntoRenderTexture(tempRT);

                    // Pixel format conversion
                    var buffer = _converter.Encode(tempRT, keepAlpha, false);
                    RenderTexture.ReleaseTemporary(tempRT);

                    // Readback entry allocation and request
                    _pool.NewEntry(w, h, keepAlpha, metadata)
                    .RequestReadback(buffer, _onReadback);
                }
            }
        }
コード例 #17
0
        protected internal override void NewFrameReady(RecordingSession session)
        {
            Profiler.BeginSample("GameViewInput.NewFrameReady");
            ScreenCapture.CaptureScreenshotIntoRenderTexture(m_CaptureTexture);
            var  movieRecorderSettings = session.settings as MovieRecorderSettings;
            bool needToFlip            = scSettings.FlipFinalOutput;

            if (movieRecorderSettings != null)
            {
                bool encoderAlreadyFlips = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected].PerformsVerticalFlip;
                needToFlip &= encoderAlreadyFlips;
            }

            if (needToFlip)
            {
                OutputRenderTexture = m_VFlipper?.Flip(m_CaptureTexture);
            }

            // Force opaque alpha channel
            MakeFullyOpaque(OutputRenderTexture);
            Profiler.EndSample();
        }
コード例 #18
0
        ComputeBuffer CaptureImmediate()
        {
            PrepareInternalObjects();

            // Texture capture method
            // Simply convert the source texture and return it.
            if (_captureMethod == CaptureMethod.Texture)
            {
                if (_sourceTexture == null)
                {
                    return(null);
                }

                _width  = _sourceTexture.width;
                _height = _sourceTexture.height;

                return(_converter.Encode(_sourceTexture, _enableAlpha));
            }

            // Game View capture method
            // Capture the screen into a temporary RT, then convert it.
            if (_captureMethod == CaptureMethod.GameView)
            {
                _width  = Screen.width;
                _height = Screen.height;

                var tempRT = RenderTexture.GetTemporary(_width, _height, 0);

                ScreenCapture.CaptureScreenshotIntoRenderTexture(tempRT);
                var converted = _converter.Encode(tempRT, _enableAlpha);

                RenderTexture.ReleaseTemporary(tempRT);
                return(converted);
            }

            Debug.LogError("Wrong capture method.");
            return(null);
        }
コード例 #19
0
    IEnumerator Test1()
    {
        //Debug.LogError("one");
        while (true)
        {
            //yield return new WaitForSeconds(1);
            // yield return new WaitForEndOfFrame();

            var rt = RenderTexture.GetTemporary(Screen.width, Screen.height, 0, RenderTextureFormat.ARGB32);
            ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
            System.Diagnostics.Stopwatch wTime = new System.Diagnostics.Stopwatch();
            wTime.Start();
            var req = AsyncGPUReadback.Request(rt, 0, TextureFormat.ARGB32);
            yield return(new WaitUntil(() => req.done));

            wTime.Stop();
            Debug.LogError("reqeust time :" + wTime.ElapsedTicks / 10000.0f + "ms");
            //var colorArray = req.GetData<Color32>().ToArray();

            var tex = new Texture2D(Screen.width, Screen.height, TextureFormat.ARGB32, false);
            tex.LoadRawTextureData(req.GetData <uint>());
            tex.Apply();
            File.WriteAllBytes(@"D:\test\test" + curRequestIndex + ".png", ImageConversion.EncodeToPNG(tex));
            RenderTexture.ReleaseTemporary(rt);
            Destroy(tex);


            curRequestIndex++;
            Debug.LogError(curRequestIndex);
            if (curRequestIndex == 100)
            {
                yield break;
            }
            Debug.LogError("after:" + curRequestIndex);
        }
    }
コード例 #20
0
    // void OnPreRender () {
    //     this.camRect = this.camera.rect;
    //     // this.scaledRect.Set(this.rectRead.x, this.rectRead.y, this.rectRead.width, this.rectRead.height);
    //     this.camera.rect = this.scaledRect;

    //     // Read screen image into render texture
    //     this.renderTexture = new RenderTexture(this.width, this.height, 0, RenderTextureFormat.ARGB32);
    //     ScreenCapture.CaptureScreenshotIntoRenderTexture(this.renderTexture);
    // }

    // void OnRenderImage (RenderTexture src, RenderTexture dest) {
    //     this.camera.rect = this.camRect;
    //     src.filterMode = this.filterMode;
    //     Graphics.Blit(src, dest);
    // }

    IEnumerator Start()
    {
        // this.width = Screen.width;
        // this.height = Screen.height;

        int divWidth  = this.width / divisions;
        int divHeight = this.height / divisions;

        Debug.LogFormat("width: {0}, height: {1}", divWidth, divHeight);

        while (!Teleportal.Teleportal.tp.IsConnected() || !Teleportal.AuthModule.Shared.IsAuthed())
        {
            // Wait for connection
            yield return(new WaitForSeconds(0.2f));
        }

        while (Teleportal.Teleportal.tp.IsConnected())
        {
            // Wait for the specified delay
            yield return(new WaitForSeconds(this.NetworkInterval));

            if (!this.screenTxEnabled)
            {
                continue;
            }

            yield return(new WaitForEndOfFrame());

            // Read screen image into render texture
            this.renderTexture = new RenderTexture(this.width, this.height, 0, RenderTextureFormat.ARGB32);
            ScreenCapture.CaptureScreenshotIntoRenderTexture(this.renderTexture);

            // Async read bytes operation
            // AsyncGPUReadback.Request(this.renderTexture, 0, TextureFormat.ARGB32, this.ReadbackCompleted);

            RenderTexture.active = this.renderTexture;

            this.byteArrs   = new List <byte[]>();
            this.byteArrLen = 0;

            for (int i = 0; i < divisions; i++)
            {
                int x = divWidth * i;
                int y = divHeight * i;
                Debug.LogFormat("width_height {0} {1} x_y {2} {3}", width, height, x, y);
                this.t2d      = new Texture2D(divWidth, divHeight, TextureFormat.ARGB32, false);
                this.rectRead = new Rect(x, y, divWidth, divHeight);
                Debug.Log(Camera.main.rect);
                this.t2d.ReadPixels(this.rectRead, 0, 0);
                // this.t2d.Compress(false);
                this.t2d.Apply();

                byte[] tmp = t2d.GetRawTextureData <byte>().ToArray();
                this.byteArrs.Add(tmp);
                byteArrLen += tmp.Length;
                yield return(new WaitForSeconds(this.divisionInterval));
            }

            RenderTexture.active = null;

            Thread t = new Thread(this.ByteArrayToString);
            t.Start(null);//ba);
        }
    }
コード例 #21
0
        private IEnumerator VideoRecoder()
        {
            while (isFinish == false)
            {
                yield return(new WaitForEndOfFrame());

                if (isPlay == false)
                {
                    continue;
                }
                if (isPause == false)
                {
                    frameCount--;
                }
                if (frameCount >= 0 || isAsyncGPUReadBackFinish == false)
                {
                    continue;
                }
                if (isFinish == true)
                {
                    break;
                }
                switch (captureMode)
                {
                    #if UNITY_2019_1_OR_NEWER
                case CaptureMode.AsyncGPUReadBack:
                {
                    if (
                        (textureHeader == null) ||
                        (renderTexture == null) ||
                        (renderTexture.width != Screen.currentResolution.width) ||
                        (renderTexture.height != Screen.currentResolution.height)
                        )
                    {
                        if (renderTexture != null)
                        {
                            renderTexture.Release();
                            Destroy(renderTexture);
                        }
                        renderTexture = new RenderTexture(
                            Screen.currentResolution.width,
                            Screen.currentResolution.height,
                            0
                            );
                        var header = new TextureHeader(renderTexture.width, renderTexture.height, TextureFormat.RGBA32, false, true);
                        var bf     = new BinaryFormatter();
                        var ms     = new MemoryStream();
                        try
                        {
                            bf.Serialize(ms, header);
                            PlayerConnection.instance.Send(PlayerView.kMsgSendPlayerToEditorHeader, ms.ToArray());
                        }
                        finally
                        {
                            ms.Close();
                        }
                        textureHeader = header;
                    }
                    frameCount = frameCountMax;
                    isAsyncGPUReadBackFinish = false;

                    ScreenCapture.CaptureScreenshotIntoRenderTexture(renderTexture);
                    AsyncGPUReadback.Request(renderTexture, 0, TextureFormat.RGBA32, ReadbackCompleted);
                }
                break;

                case CaptureMode.Normal:
                    #else
                default:
                    #endif
                {
                    var texture2D = ScreenCapture.CaptureScreenshotAsTexture();
                    var header    = new TextureHeader(texture2D.width, texture2D.height, TextureFormat.RGBA32, false, false);
                    if (textureHeader == null || textureHeader != header)
                    {
                        var bf = new BinaryFormatter();
                        var ms = new MemoryStream();
                        try
                        {
                            bf.Serialize(ms, header);
                            PlayerConnection.instance.Send(PlayerView.kMsgSendPlayerToEditorHeader, ms.ToArray());
                        }
                        finally
                        {
                            ms.Close();
                        }
                        textureHeader = header;
                    }
                    PlayerConnection.instance.Send(
                        PlayerView.kMsgSendPlayerToEditor,
                        texture2D.GetRawTextureData()
                        );
                    Destroy(texture2D);
                    frameCount = frameCountMax;
                }
                break;
                }
            }
        }
コード例 #22
0
        /// <summary>
        /// Get path to game screenshot when exception occured
        /// </summary>
        /// <returns>Path to game screenshot</returns>
        private string GetScreenshotPath(string dataPrefix)
        {
            if (!_settings.GenerateScreenshotOnException)
            {
                return(string.Empty);
            }
            var screenshotPath = Path.Combine(_settings.DatabasePath, string.Format("{0}-screen.jpg", dataPrefix));

            lock (_lock)
            {
                if (BacktraceDatabase.LastFrameTime == _lastScreenTime)
                {
                    if (File.Exists(_lastScreenPath))
                    {
                        File.Copy(_lastScreenPath, screenshotPath);
                        return(screenshotPath);
                    }
                    return(_lastScreenPath);
                }
                else
                {
                    Texture2D result;
                    if (ScreenshotMaxHeight < Screen.height)
                    {
                        float ratio        = Screen.width / Screen.height;
                        int   targetHeight = Mathf.Min(Screen.height, ScreenshotMaxHeight);
                        int   targetWidth  = Mathf.RoundToInt(targetHeight * ratio);

#if UNITY_2019_1_OR_NEWER
                        RenderTexture screenTexture = RenderTexture.GetTemporary(Screen.width, Screen.height);
                        ScreenCapture.CaptureScreenshotIntoRenderTexture(screenTexture);
#else
                        Texture2D screenTexture = ScreenCapture.CaptureScreenshotAsTexture();
#endif

                        // Create a render texture to render into
                        RenderTexture rt = RenderTexture.GetTemporary(targetWidth, targetHeight);

                        if (SystemInfo.graphicsUVStartsAtTop)
                        {
                            Graphics.Blit(screenTexture, rt, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 1.0f));
                        }
                        else
                        {
                            Graphics.Blit(screenTexture, rt);
                        }

                        RenderTexture previousActiveRT = RenderTexture.active;
                        RenderTexture.active = rt;

                        // Create a texture & read data from the active RenderTexture
                        result = new Texture2D(targetWidth, targetHeight, TextureFormat.RGB24, false);
                        result.ReadPixels(new Rect(0, 0, targetWidth, targetHeight), 0, 0);
                        result.Apply();

                        // Reset to initial state
                        RenderTexture.active = previousActiveRT;

                        RenderTexture.ReleaseTemporary(rt);

#if UNITY_2019_1_OR_NEWER
                        RenderTexture.ReleaseTemporary(screenTexture);
#else
                        GameObject.Destroy(screenTexture);
#endif
                    }
                    else
                    {
                        result = ScreenCapture.CaptureScreenshotAsTexture();
                    }

                    File.WriteAllBytes(screenshotPath, result.EncodeToJPG(ScreenshotQuality));
                    GameObject.Destroy(result);

                    _lastScreenTime = BacktraceDatabase.LastFrameTime;
                    _lastScreenPath = screenshotPath;
                }
            }
            return(screenshotPath);
        }