Exemplo n.º 1
0
		private void ApplyMapping(Texture texture, bool requiresYFlip, int plane, int materialIndex = -1)
		{
			if (_renderer != null)
			{
				_isDirty = false;

				Material[] meshMaterials = _renderer.materials;
				if (meshMaterials != null)
				{
					for (int i = 0; i < meshMaterials.Length; i++)
					{
						if (_materialIndex < 0 || i == _materialIndex)
						{
							Material mat = meshMaterials[i];
							if (mat != null)
							{
								if (plane == 0)
								{
									VideoRender.SetupMaterialForMedia(mat, _media, _propTexture.Id, texture);
									_lastTextureApplied = texture;

									if(texture == _defaultTexture)	{ mat.EnableKeyword("USING_DEFAULT_TEXTURE"); }
									else							{ mat.DisableKeyword("USING_DEFAULT_TEXTURE"); }

									if (texture != null)
									{
										if (requiresYFlip)
										{
											mat.SetTextureScale(_propTexture.Id, new Vector2(_scale.x, -_scale.y));
											mat.SetTextureOffset(_propTexture.Id, Vector2.up + _offset);
										}
										else
										{
											mat.SetTextureScale(_propTexture.Id, _scale);
											mat.SetTextureOffset(_propTexture.Id, _offset);
										}
									}
								}
								else if (plane == 1)
								{
									if (texture != null)
									{
										if (requiresYFlip)
										{
											mat.SetTextureScale(VideoRender.PropChromaTex.Id, new Vector2(_scale.x, -_scale.y));
											mat.SetTextureOffset(VideoRender.PropChromaTex.Id, Vector2.up + _offset);
										}
										else
										{
											mat.SetTextureScale(VideoRender.PropChromaTex.Id, _scale);
											mat.SetTextureOffset(VideoRender.PropChromaTex.Id, _offset);
										}
									}
								}
							}
						}
					}
				}
			}
		}
Exemplo n.º 2
0
        private void ApplyMapping(Texture texture, bool requiresYFlip, int plane = 0)
        {
            if (_material != null)
            {
                _isDirty = false;

                if (plane == 0)
                {
                    VideoRender.SetupMaterialForMedia(_material, _media, _propTexture.Id, texture);
                    _lastTextureApplied = texture;

                    if (texture == _defaultTexture)
                    {
                        _material.EnableKeyword("USING_DEFAULT_TEXTURE");
                    }
                    else
                    {
                        _material.DisableKeyword("USING_DEFAULT_TEXTURE");
                    }

                    if (texture != null)
                    {
                        if (requiresYFlip)
                        {
                            _material.SetTextureScale(_propTexture.Id, new Vector2(_scale.x, -_scale.y));
                            _material.SetTextureOffset(_propTexture.Id, Vector2.up + _offset);
                        }
                        else
                        {
                            _material.SetTextureScale(_propTexture.Id, _scale);
                            _material.SetTextureOffset(_propTexture.Id, _offset);
                        }
                    }
                }
                else if (plane == 1)
                {
                    if (texture != null)
                    {
                        if (requiresYFlip)
                        {
                            _material.SetTextureScale(VideoRender.PropChromaTex.Id, new Vector2(_scale.x, -_scale.y));
                            _material.SetTextureOffset(VideoRender.PropChromaTex.Id, Vector2.up + _offset);
                        }
                        else
                        {
                            _material.SetTextureScale(VideoRender.PropChromaTex.Id, _scale);
                            _material.SetTextureOffset(VideoRender.PropChromaTex.Id, _offset);
                        }
                    }
                }
            }
        }
Exemplo n.º 3
0
        internal static void SetupMaterial(Material material, bool flipVertically, bool playerSupportsLinear, Matrix4x4 ycbcrTransform, Texture ycbcrTexture = null, float[] textureTransform = null,
                                           VideoMapping mapping = VideoMapping.Normal, StereoPacking stereoPacking = StereoPacking.None, AlphaPacking alphaPacking = AlphaPacking.None)
        {
            SetupVerticalFlipMaterial(material, flipVertically);

            // Apply changes for layout
            if (material.HasProperty(VideoRender.PropLayout.Id))
            {
                VideoRender.SetupLayoutMaterial(material, mapping);
            }

            // Apply changes for stereo videos
            if (material.HasProperty(VideoRender.PropStereo.Id))
            {
                VideoRender.SetupStereoMaterial(material, stereoPacking);
            }

            // Apply changes for alpha videos
            if (material.HasProperty(VideoRender.PropAlphaPack.Id))
            {
                VideoRender.SetupAlphaPackedMaterial(material, alphaPacking);
            }

            // Apply gamma correction
                        #if UNITY_PLATFORM_SUPPORTS_LINEAR
            if (material.HasProperty(VideoRender.PropApplyGamma.Id))
            {
                VideoRender.SetupGammaMaterial(material, playerSupportsLinear);
            }
                        #endif

            // Adjust for cropping (when the decoder decodes in blocks that overrun the video frame size, it pads), OES only as we apply this lower down for none-OES
                        #if (!UNITY_EDITOR && UNITY_ANDROID)
// STE: HasProperty doesn't work on Matrix'
//			if (material.HasProperty(VideoRender.PropTextureMatrix.Id))
            {
                VideoRender.SetupTextureMatrix(material, textureTransform);
            }
                        #endif

                        #if UNITY_PLATFORM_SUPPORTS_YPCBCR
            VideoRender.SetupYpCbCrMaterial(material, ycbcrTexture != null, ycbcrTransform, ycbcrTexture);
                        #endif
        }
Exemplo n.º 4
0
        // We do a LateUpdate() to allow for any changes in the texture that may have happened in Update()
        void LateUpdate()
        {
            if (_setNativeSize)
            {
                SetNativeSize();
            }

            if (_lastTexture != mainTexture)
            {
                _lastTexture = mainTexture;
                SetVerticesDirty();
                SetMaterialDirty();
            }

            if (HasValidTexture())
            {
                if (mainTexture != null)
                {
                    Orientation orientation = Helper.GetOrientation(_mediaPlayer.Info.GetTextureTransform());
                    if (mainTexture.width != _lastWidth || mainTexture.height != _lastHeight || orientation != _lastOrientation)
                    {
                        _lastWidth       = mainTexture.width;
                        _lastHeight      = mainTexture.height;
                        _lastOrientation = orientation;
                        SetVerticesDirty();
                        SetMaterialDirty();
                    }
                }
            }

            if (Application.isPlaying)
            {
                if (!_isUserMaterial)
                {
                    UpdateInternalMaterial();
                }
            }

            if (material != null && _mediaPlayer != null)
            {
                // TODO: only run when dirty
                VideoRender.SetupMaterialForMedia(materialForRendering, _mediaPlayer);
            }
        }
Exemplo n.º 5
0
        public static RenderTexture ResolveVideoToRenderTexture(Material resolveMaterial, RenderTexture targetTexture, ITextureProducer texture, ResolveFlags flags, ScaleMode scaleMode = ScaleMode.StretchToFill)
        {
            int targetWidth  = texture.GetTexture(0).width;
            int targetHeight = texture.GetTexture(0).height;

            GetResolveTextureSize(texture.GetTextureAlphaPacking(), texture.GetTextureStereoPacking(), StereoEye.Left, ref targetWidth, ref targetHeight);

            if (targetTexture)
            {
                bool sizeChanged = (targetTexture.width != targetWidth || targetTexture.height != targetHeight);
                if (sizeChanged)
                {
                    RenderTexture.ReleaseTemporary(targetTexture); targetTexture = null;
                }
            }

            if (!targetTexture)
            {
                RenderTextureReadWrite readWrite = ((flags & ResolveFlags.ColorspaceSRGB) == ResolveFlags.ColorspaceSRGB) ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear;
                targetTexture = RenderTexture.GetTemporary(targetWidth, targetHeight, 0, RenderTextureFormat.ARGB32, readWrite);
            }

            // Set target mipmap generation support
            {
                bool requiresMipmap   = (flags & ResolveFlags.Mipmaps) == ResolveFlags.Mipmaps;
                bool requiresRecreate = (targetTexture.IsCreated() && targetTexture.useMipMap != requiresMipmap);
                if (requiresRecreate)
                {
                    targetTexture.Release();
                }
                if (!targetTexture.IsCreated())
                {
                    targetTexture.useMipMap = targetTexture.autoGenerateMips = requiresMipmap;
                    targetTexture.Create();
                }
            }

            // Render resolve blit
            // TODO: combine these two paths into a single material blit
            {
                bool prevSRGB = GL.sRGBWrite;
                GL.sRGBWrite = targetTexture.sRGB;
                RenderTexture prev = RenderTexture.active;
                if (scaleMode == ScaleMode.StretchToFill)
                {
                    Graphics.Blit(texture.GetTexture(0), targetTexture, resolveMaterial);
                }
                else
                {
                    RenderTexture.active = targetTexture;
                    bool partialAreaRender = (scaleMode == ScaleMode.ScaleToFit);
                    if (partialAreaRender)
                    {
                        GL.Clear(false, true, Color.black);
                    }
                    VideoRender.DrawTexture(new Rect(0f, 0f, targetTexture.width, targetTexture.height), texture.GetTexture(0), scaleMode, texture.GetTextureAlphaPacking(), resolveMaterial);
                }
                RenderTexture.active = prev;
                GL.sRGBWrite         = prevSRGB;
            }

            return(targetTexture);
        }
Exemplo n.º 6
0
        void OnGUI()
        {
#if UNITY_EDITOR
            if (_showAreaInEditor && !Application.isPlaying)
            {
                DrawArea();
                return;
            }
#endif

            if (_mediaPlayer == null)
            {
                return;
            }

            Texture texture = null;
            if (_showAreaInEditor)
            {
#if UNITY_EDITOR
                texture = Texture2D.whiteTexture;
#endif
            }
            texture = VideoRender.GetTexture(_mediaPlayer, 0);
            if (_mediaPlayer.Info != null && !_mediaPlayer.Info.HasVideo())
            {
                texture = null;
            }

            if (texture != null)
            {
                bool isTextureVisible = (_color.a > 0f || !_allowTransparency);
                if (isTextureVisible)
                {
                    GUI.depth = _depth;
                    GUI.color = _color;

                    Rect rect = GetAreaRect();

                    // TODO: change this to a material-only path so we only have a single drawing path
                    if (_material != null)
                    {
                        // TODO: Only setup material when needed
                        VideoRender.SetupMaterialForMedia(_material, _mediaPlayer);

                        // NOTE: It seems that Graphics.DrawTexture() behaves differently than GUI.DrawTexture() when it comes to sRGB writing
                        // on newer versions of Unity (at least 2018.2.19 and above), so now we have to force the conversion to sRGB on writing
                        bool restoreSRGBWrite = false;
#if UNITY_EDITOR_WIN || (!UNITY_EDITOR && UNITY_STANDALONE_WIN)
                        if (QualitySettings.activeColorSpace == ColorSpace.Linear && !GL.sRGBWrite)
                        {
                            restoreSRGBWrite = true;
                        }
#endif
                        if (restoreSRGBWrite)
                        {
                            GL.sRGBWrite = true;
                        }

                        VideoRender.DrawTexture(rect, texture, _scaleMode, _mediaPlayer.TextureProducer.GetTextureAlphaPacking(), _material);

                        if (restoreSRGBWrite)
                        {
                            GL.sRGBWrite = false;
                        }
                    }
                    else
                    {
                        bool requiresVerticalFlip = false;
                        if (_mediaPlayer.TextureProducer != null)
                        {
                            requiresVerticalFlip = _mediaPlayer.TextureProducer.RequiresVerticalFlip();
                        }
                        if (requiresVerticalFlip)
                        {
                            GUIUtility.ScaleAroundPivot(new Vector2(1f, -1f), new Vector2(0f, rect.y + (rect.height / 2f)));
                        }
                        GUI.DrawTexture(rect, texture, _scaleMode, _allowTransparency);
                    }
                }
            }
        }