Пример #1
0
        public void DisposeTextures()
        {
            TC_Compute.DisposeRenderTextures(ref rtSplatmaps);
            TC_Compute.DisposeRenderTexture(ref rtColormap);

            for (int i = 0; i < terrains.Count; i++)
            {
                terrains[i].DisposeTextures();
            }
        }
Пример #2
0
        public bool ComputeMulti(ref RenderTexture[] renderTextures, float seedParent, bool doNormalize, bool first = false)
        {
            TC_Compute compute = TC_Compute.instance;

            RenderTexture[] rtsLayer       = null;
            RenderTexture   rtRightPreview = null;
            RenderTexture   rtLeftPreview  = null;

            RenderTexture[] rtsPreview = null;
            // RenderTexture rtPreview2 = null;
            ComputeBuffer layerMaskBuffer = null;
            TC_LayerGroup layerGroup;
            TC_Layer      layer;
            bool          firstCompute = false;
            bool          lastCompute  = false;

            int even = 0;

            rtsPreview = new RenderTexture[2];

            SetPreviewTextureBefore();

            float seedTotal = seed + seedParent;

            for (int i = 0; i < itemList.Count; i++)
            {
                layer = itemList[i] as TC_Layer;

                if (layer != null)
                {
                    if (!layer.active)
                    {
                        continue;
                    }
                    // InitPreview(ref layer.previewRenderTex);

                    if (!firstCompute)
                    {
                        firstCompute = layer.ComputeMulti(ref renderTextures, ref layerMaskBuffer, seedTotal, i == firstActive);

                        if (firstCompute)
                        {
                            rtLeftPreview = layer.rtDisplay;
                            TC_Reporter.Log("firt compute " + layer.maskNodeGroup.totalActive);
                            compute.DisposeBuffer(ref layerMaskBuffer);
                        }
                    }
                    else
                    {
                        TC_Compute.InitRenderTextures(ref rtsLayer, "rtsLayer", renderTextures.Length);
                        lastCompute = layer.ComputeMulti(ref rtsLayer, ref layerMaskBuffer, seedTotal);

                        if (lastCompute)
                        {
                            TC_Reporter.Log("Run layer method multi");
                            rtRightPreview = (layer.method == Method.Lerp) ? layer.selectNodeGroup.rtColorPreview : layer.rtDisplay;
                            // Debug.Log(rtRight.name+ " "+ (layer.maskNodeGroup.activeTotal == 0 || layer.method == Method.Lerp));

                            if (outputId == TC.colorOutput)
                            {
                                compute.RunComputeColorMethod(layer, layer.method, ref renderTextures[0], ref rtsLayer[0], layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }
                            else
                            {
                                compute.RunComputeMultiMethod(layer, layer.method, i == lastActive && doNormalize, ref renderTextures, ref rtsLayer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }

                            compute.DisposeBuffer(ref layerMaskBuffer);
                        }
                    }
                }
                else
                {
                    layerGroup = itemList[i] as TC_LayerGroup;
                    if (layerGroup == null)
                    {
                        continue;
                    }
                    if (!layerGroup.active)
                    {
                        continue;
                    }

                    if (!firstCompute)
                    {
                        firstCompute = layerGroup.ComputeMulti(ref renderTextures, ref layerMaskBuffer, seedTotal, i == firstActive);
                        if (firstCompute)
                        {
                            rtLeftPreview = layerGroup.rtDisplay;
                            compute.DisposeBuffer(ref layerMaskBuffer);
                            TC_Reporter.Log("LayerGroup did first compute");
                        }
                    }
                    else
                    {
                        TC_Compute.InitRenderTextures(ref rtsLayer, "rtsLayer", renderTextures.Length);
                        lastCompute = layerGroup.ComputeMulti(ref rtsLayer, ref layerMaskBuffer, seedTotal);
                        if (lastCompute)
                        {
                            // if (layerGroup.groupResult.activeTotal == 1) rtRight = layerGroup.rtDisplay; else rtRight = layerGroup.rtPreview;
                            rtRightPreview = (layerGroup.method == Method.Lerp) ? layerGroup.groupResult.rtDisplay : layerGroup.rtDisplay;

                            if (outputId == TC.colorOutput)
                            {
                                compute.RunComputeColorMethod(layerGroup, layerGroup.method, ref renderTextures[0], ref rtsLayer[0], layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }
                            else
                            {
                                compute.RunComputeMultiMethod(layerGroup, layerGroup.method, i == lastActive && doNormalize, ref renderTextures, ref rtsLayer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }

                            compute.DisposeBuffer(ref layerMaskBuffer);
                        }
                    }
                }
            }

            SetPreviewTextureAfter();

            if (layerMaskBuffer != null)
            {
                compute.DisposeBuffer(ref layerMaskBuffer); TC_Reporter.Log("Dispose layerMaskBuffer");
            }

            TC_Compute.DisposeRenderTextures(ref rtsPreview);
            TC_Compute.DisposeRenderTextures(ref rtsLayer);

            return(firstCompute);
        }
Пример #3
0
        // Compute height, trees and objects
        public ComputeBuffer ComputeSingle(float seedParent, bool first = false)
        {
            TC_Compute compute = TC_Compute.instance;

            ComputeBuffer totalBuffer     = null;
            ComputeBuffer layerBuffer     = null;
            ComputeBuffer layerMaskBuffer = null;

            RenderTexture[] rtsPreview     = null;
            RenderTexture   rtRightPreview = null;
            RenderTexture   rtLeftPreview  = null;

            if (outputId != TC.heightOutput)
            {
                rtsPreview = new RenderTexture[2];
            }

            SetPreviewTextureBefore();

            int even = 0;

            float seedTotal = seed + seedParent;

            for (int i = 0; i < itemList.Count; i++)
            {
                TC_Layer layer = itemList[i] as TC_Layer;

                if (layer != null)
                {
                    if (!layer.active)
                    {
                        TC_Reporter.Log("Inactive layer " + i); continue;
                    }

                    if (totalBuffer == null)
                    {
                        if (outputId == TC.heightOutput)
                        {
                            layer.ComputeHeight(ref totalBuffer, ref layerMaskBuffer, seedTotal, i == firstActive);
                        }
                        else
                        {
                            layer.ComputeItem(ref totalBuffer, ref layerMaskBuffer, seedTotal, i == firstActive);
                            if (totalBuffer != null)
                            {
                                rtLeftPreview = layer.rtDisplay;
                            }
                        }

                        TC_Area2D.current.layerGroupBuffer = totalBuffer; // Portal

                        compute.DisposeBuffer(ref layerMaskBuffer);
                    }
                    else
                    {
                        if (outputId == TC.heightOutput)
                        {
                            layer.ComputeHeight(ref layerBuffer, ref layerMaskBuffer, seedTotal);
                        }
                        else
                        {
                            layer.ComputeItem(ref layerBuffer, ref layerMaskBuffer, seedTotal);
                        }

                        if (layerBuffer != null)
                        {
                            if (outputId == TC.heightOutput)
                            {
                                compute.RunComputeMethod(this, layer, totalBuffer, ref layerBuffer, totalActive, i == lastActive ? rtPreview : null, layerMaskBuffer);
                            }
                            else
                            {
                                rtRightPreview = layer.rtDisplay;
                                compute.RunComputeObjectMethod(this, layer, totalBuffer, ref layerBuffer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }
                            TC_Area2D.current.layerGroupBuffer = totalBuffer;
                        }
                        compute.DisposeBuffer(ref layerMaskBuffer);
                    }
                }
                else
                {
                    TC_LayerGroup layerGroup = itemList[i] as TC_LayerGroup;
                    if (layerGroup == null)
                    {
                        continue;
                    }
                    if (!layerGroup.active)
                    {
                        continue;
                    }

                    if (totalBuffer == null)
                    {
                        layerMaskBuffer = layerGroup.ComputeSingle(ref totalBuffer, seedTotal, i == firstActive);
                        if (totalBuffer != null)
                        {
                            rtLeftPreview = layerGroup.rtDisplay;
                        }

                        TC_Area2D.current.layerGroupBuffer = totalBuffer;

                        compute.DisposeBuffer(ref layerMaskBuffer);
                    }
                    else
                    {
                        layerMaskBuffer = layerGroup.ComputeSingle(ref layerBuffer, seedTotal);

                        if (layerBuffer != null)
                        {
                            if (outputId == TC.heightOutput)
                            {
                                compute.RunComputeMethod(this, layerGroup, totalBuffer, ref layerBuffer, totalActive, i == lastActive ? rtPreview : null, layerMaskBuffer);
                            }
                            else
                            {
                                rtRightPreview = layerGroup.rtDisplay;
                                compute.RunComputeObjectMethod(this, layerGroup, totalBuffer, ref layerBuffer, layerMaskBuffer, rtPreview, ref rtsPreview[even++ % 2], ref rtLeftPreview, rtRightPreview);
                            }
                            TC_Area2D.current.layerGroupBuffer = totalBuffer;
                        }
                        compute.DisposeBuffer(ref layerMaskBuffer);
                    }
                }
            }

            SetPreviewTextureAfter();

            if (outputId != TC.heightOutput)
            {
                TC_Compute.DisposeRenderTextures(ref rtsPreview);
            }
            compute.DisposeBuffer(ref layerMaskBuffer);

            if (totalBuffer == null)
            {
                TC_Reporter.Log("Layer buffer null");
            }
            return(totalBuffer);
        }