完成rt预览

Assets/Scripts/UI/Common/ModelViewer/ModelViewRenderImage.cs

@@ -46,9 +46,7 @@ namespace NBF
 
             Object prefab = Resources.Load("RenderTexture/RenderImageCamera");
             GameObject go = (GameObject)Object.Instantiate(prefab, _root, false);
-
-            // ConfigurableJoint
-
+            
             _camera = go.GetComponent<Camera>();
             _camera.transform.position = Vector3.zero;
             _camera.cullingMask = 1 << RENDER_LAYER;
@@ -116,6 +114,7 @@ namespace NBF
 
 
             _camera.clearFlags = CameraClearFlags.Nothing;
+            _camera.backgroundColor = new Color(0, 0, 0, 0); // 完全透明
             _camera.transform.position = _viewerSettings.cameraPosition;
             _camera.transform.LookAt(_viewerSettings.cameraTarget);
             _camera.orthographic = _viewerSettings.cameraOrtho;
@@ -135,6 +134,13 @@ namespace NBF
             _camera.depthTextureMode = DepthTextureMode.Depth;
             _camera.clearFlags = CameraClearFlags.Color;
             _camera.GetUniversalAdditionalCameraData().renderPostProcessing = false; //URP only
+
+            // var urpCamData = _camera.GetUniversalAdditionalCameraData();
+            // urpCamData.renderPostProcessing = false;
+            // urpCamData.requiresColorOption = CameraOverrideOption.On;
+            // urpCamData.requiresDepthOption = CameraOverrideOption.Off;
+            // urpCamData.requiresColorTexture = false;
+            // urpCamData.SetRenderer(1); // 关键步骤：指定“透明输出”的Renderer
         }
 
         public void Dispose()
@@ -160,8 +166,12 @@ namespace NBF
                 anisoLevel = 0,
                 useMipMap = false
             };
+            // _renderTexture.Create();
             _image.texture = new NTexture(_renderTexture);
-            _image.blendMode = BlendMode.Off;
+            _image.shader = "Unlit/Transparent"; //Shader.Find("Unlit/Transparent");
+            // _material = new Material(Shader.Find("Unlit/Transparent"));
+            // _image.blendMode = BlendMode.Off;
+            // _image.blendMode = BlendMode.Normal;
         }
 
         void DestroyTexture()
@@ -213,6 +223,8 @@ namespace NBF
             RenderTexture.active = old;
 
             SetLayer(_root.gameObject, HIDDEN_LAYER);
+
+            UpdateDebugSave();
         }
 
         void SetLayer(GameObject go, int layer)
@@ -223,5 +235,165 @@ namespace NBF
                 t.gameObject.layer = layer;
             }
         }
+
+
+        #region MyRegion
+
+        /// <summary>
+        /// The rendertexture is not transparent. So if you want to the UI elements can be seen in the back of the models/particles in rendertexture,
+        /// you can set a maximunm two images for background.
+        /// Be careful if your image is 9 grid scaling, you must make sure the place holder is inside the middle box(dont cover from border to middle).
+        /// </summary>
+        /// <param name="image"></param>
+        public void SetBackground(GObject image)
+        {
+            SetBackground(image, null);
+        }
+
+        /// <summary>
+        /// The rendertexture is not transparent. So if you want to the UI elements can be seen in the back of the models/particles in rendertexture,
+        /// you can set a maximunm two images for background.
+        /// </summary>
+        /// <param name="image1"></param>
+        /// <param name="image2"></param>
+        public void SetBackground(GObject image1, GObject image2)
+        {
+            Image source1 = (Image)image1.displayObject;
+            Image source2 = image2 != null ? (Image)image2.displayObject : null;
+
+            Vector3 pos = _background.position;
+            pos.z = _camera.farClipPlane;
+            _background.position = pos;
+
+            Vector2[] uv = new Vector2[4];
+            Vector2[] uv2 = null;
+
+            Rect rect = _image.TransformRect(new Rect(0, 0, this._width, this._height), source1);
+            Rect uvRect = GetImageUVRect(source1, rect, uv);
+
+            if (source2 != null)
+            {
+                rect = _image.TransformRect(new Rect(0, 0, this._width, this._height), source2);
+                uv2 = new Vector2[4];
+                GetImageUVRect(source2, rect, uv2);
+            }
+
+            Vector3[] vertices = new Vector3[4];
+            for (int i = 0; i < 4; i++)
+            {
+                Vector2 v = uv[i];
+                vertices[i] = new Vector3((v.x - uvRect.x) / uvRect.width * 2 - 1,
+                    (v.y - uvRect.y) / uvRect.height * 2 - 1, 0);
+            }
+
+            Mesh mesh = new Mesh();
+            mesh.vertices = vertices;
+            mesh.uv = uv;
+            if (uv2 != null)
+                mesh.uv2 = uv2;
+            mesh.colors32 = new Color32[] { Color.white, Color.white, Color.white, Color.white };
+            mesh.triangles = new int[] { 0, 1, 2, 2, 3, 0 };
+
+            MeshFilter meshFilter = this._background.gameObject.GetComponent<MeshFilter>();
+            if (meshFilter == null)
+                meshFilter = this._background.gameObject.AddComponent<MeshFilter>();
+            meshFilter.mesh = mesh;
+            MeshRenderer meshRenderer = this._background.gameObject.GetComponent<MeshRenderer>();
+            if (meshRenderer == null)
+                meshRenderer = this._background.gameObject.AddComponent<MeshRenderer>();
+#if (UNITY_5 || UNITY_5_3_OR_NEWER)
+            meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
+#else
+        meshRenderer.castShadows = false;
+#endif
+            meshRenderer.receiveShadows = false;
+            Shader shader = Shader.Find("Game/FullScreen");
+            Material mat = new Material(shader);
+            mat.mainTexture = source1.texture.nativeTexture;
+            if (source2 != null)
+                mat.SetTexture("_Tex2", source2.texture.nativeTexture);
+            meshRenderer.material = mat;
+        }
+
+        Rect GetImageUVRect(Image image, Rect localRect, Vector2[] uv)
+        {
+            Rect imageRect = new Rect(0, 0, image.size.x, image.size.y);
+            Rect bound = ToolSet.Intersection(ref imageRect, ref localRect);
+            Rect uvRect = image.texture.uvRect;
+
+            if (image.scale9Grid != null)
+            {
+                Rect gridRect = (Rect)image.scale9Grid;
+                float sourceW = image.texture.width;
+                float sourceH = image.texture.height;
+                uvRect = Rect.MinMaxRect(Mathf.Lerp(uvRect.xMin, uvRect.xMax, gridRect.xMin / sourceW),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax, (sourceH - gridRect.yMax) / sourceH),
+                    Mathf.Lerp(uvRect.xMin, uvRect.xMax, gridRect.xMax / sourceW),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax, (sourceH - gridRect.yMin) / sourceH));
+
+                float vw = imageRect.width - (sourceW - gridRect.width);
+                float vh = imageRect.height - (sourceH - gridRect.height);
+                uvRect = Rect.MinMaxRect(Mathf.Lerp(uvRect.xMin, uvRect.xMax, (bound.x - gridRect.x) / vw),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax,
+                        (imageRect.height - bound.yMax - (sourceH - gridRect.yMax)) / vh),
+                    Mathf.Lerp(uvRect.xMin, uvRect.xMax, (bound.xMax - gridRect.x) / vw),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax, (imageRect.height - bound.yMin - gridRect.y) / vh));
+            }
+            else
+            {
+                uvRect = Rect.MinMaxRect(Mathf.Lerp(uvRect.xMin, uvRect.xMax, bound.xMin / imageRect.width),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax, (imageRect.height - bound.yMax) / imageRect.height),
+                    Mathf.Lerp(uvRect.xMin, uvRect.xMax, bound.xMax / imageRect.width),
+                    Mathf.Lerp(uvRect.yMin, uvRect.yMax, (imageRect.height - bound.yMin) / imageRect.height));
+            }
+
+            uv[0] = uvRect.position;
+            uv[1] = new Vector2(uvRect.xMin, uvRect.yMax);
+            uv[2] = new Vector2(uvRect.xMax, uvRect.yMax);
+            uv[3] = new Vector2(uvRect.xMax, uvRect.yMin);
+
+            if (image.texture.rotated)
+                ToolSet.RotateUV(uv, ref image.texture.uvRect);
+
+            return uvRect;
+        }
+
+        #endregion
+
+        #region MyRegion
+
+        void UpdateDebugSave()
+        {
+            if (Input.GetKeyDown(KeyCode.F9))
+            {
+                SaveRenderTextureToPNG(_renderTexture, "RenderTextureDebug.png");
+            }
+        }
+
+        void SaveRenderTextureToPNG(RenderTexture rt, string fileName)
+        {
+            if (rt == null)
+            {
+                Debug.LogWarning("RenderTexture 为 null，无法保存。");
+                return;
+            }
+
+            RenderTexture current = RenderTexture.active;
+            RenderTexture.active = rt;
+
+            Texture2D tex = new Texture2D(rt.width, rt.height, TextureFormat.RGBA32, false);
+            tex.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
+            tex.Apply();
+
+            byte[] bytes = tex.EncodeToPNG();
+            string path = System.IO.Path.Combine(Application.dataPath, "../" + fileName);
+            System.IO.File.WriteAllBytes(path, bytes);
+            Debug.Log($"✅ RenderTexture 已保存到: {path}");
+
+            UnityEngine.Object.Destroy(tex);
+            RenderTexture.active = current;
+        }
+
+        #endregion
     }
 }