Example #1
0
        /// <summary>
        /// Create a new object that can write data into a render texture of dimensions w and h.
        /// </summary>
        public WriteFloat(int w, int h)
        {
//			Shader shader = Shader.Find("EncodeFloat/WriteToFloat");
            Shader shader = ShaderTool.GetShader2("CompiledWriteToFloat.shader");

            if (shader == null)
            {
                throw new InvalidOperationException("Could not find shader EncodeFloat/WriteToFloat. Did you change the shaders name?");
            }

            m_writeToFloat = new Material(shader);

            m_width  = w;
            m_height = h;

            m_mapR            = new Texture2D(w, h, TextureFormat.ARGB32, false, true);
            m_mapR.filterMode = FilterMode.Point;
            m_mapR.wrapMode   = TextureWrapMode.Clamp;

            m_mapG            = new Texture2D(w, h, TextureFormat.ARGB32, false, true);
            m_mapG.filterMode = FilterMode.Point;
            m_mapG.wrapMode   = TextureWrapMode.Clamp;

            m_mapB            = new Texture2D(w, h, TextureFormat.ARGB32, false, true);
            m_mapB.filterMode = FilterMode.Point;
            m_mapB.wrapMode   = TextureWrapMode.Clamp;

            m_mapA            = new Texture2D(w, h, TextureFormat.ARGB32, false, true);
            m_mapA.filterMode = FilterMode.Point;
            m_mapA.wrapMode   = TextureWrapMode.Clamp;
        }
Example #2
0
        public FourierGPU(int size)
        {
            if (size > 256)
            {
                Debug.Log("FourierGPU::FourierGPU - fourier grid size must not be greater than 256, changing to 256");
                size = 256;
            }

            if (!Mathf.IsPowerOfTwo(size))
            {
                Debug.Log("FourierGPU::FourierGPU - fourier grid size must be pow2 number, changing to nearest pow2 number");
                size = Mathf.NextPowerOfTwo(size);
            }

//		Shader shader = Shader.Find("Math/Fourier");
            Shader shader = ShaderTool.GetShader2("CompiledFourier.shader");

            if (shader == null)
            {
                Debug.Log("FourierGPU::FourierGPU - Could not find shader Math/Fourier");
            }

            m_fourier = new Material(shader);

            m_size   = size;   //must be pow2 num
            m_fsize  = (float)m_size;
            m_passes = (int)(Mathf.Log(m_fsize) / Mathf.Log(2.0f));

            m_butterflyLookupTable = new Texture2D[m_passes];

            ComputeButterflyLookupTable();

            m_fourier.SetFloat("_Size", m_fsize);
        }
        void OnPreRender()
        {
//		if (!enabled || !gameObject.active) return;

            if (!_depthCam)
            {
                _depthCam = new GameObject("CustomDepthCamera");
                _depthCam.AddComponent <Camera>();
                _depthCam.camera.enabled = true;
                //_depthCam.hideFlags = HideFlags.HideAndDontSave;
//			_depthCam.camera.depthTextureMode = DepthTextureMode.None;

                depthShader = ShaderTool.GetShader2("CompiledDepthTexture.shader");

                viewCustomBufferShader = ShaderTool.GetMatFromShader2("CompiledviewCustomDepthTexture.shader");
                viewCustomBufferShader.SetTexture("_DepthTex", _depthTex);
            }

            _depthCam.camera.CopyFrom(inCamera);
            //_depthCam.camera.backgroundColor = new Color(0,0,0,0);
            //_depthCam.camera.clearFlags = CameraClearFlags.SolidColor;
            //_depthCam.camera.cullingMask = 1 << LayerMask.NameToLayer("Character1") |
            //	1 << LayerMask.NameToLayer("Character2");



            //inCamera.camera.SetReplacementShader(depthShader,"RenderType");

            //disable rendering of the custom depth buffer when away from PQS
            if (incore.pqsEnabled)
            {
                _depthCam.camera.targetTexture = _depthTex;

                _depthCam.camera.SetReplacementShader(depthShader, "RenderType");

                _depthCam.camera.RenderWithShader(depthShader, "RenderType");
            }
        }
Example #4
0
        void OnPreRender()
        {
            //		if (!enabled || !gameObject.active) return;

            if (!_depthCam)
            {
                _depthCam       = new GameObject("CustomDepthCamera");
                _depthCamCamera = _depthCam.AddComponent <Camera>();

                _depthCamCamera.CopyFrom(inCamera);

                _depthCamCamera.farClipPlane     = incore.farCamera.farClipPlane;
                _depthCamCamera.nearClipPlane    = incore.farCamera.nearClipPlane;
                _depthCamCamera.depthTextureMode = DepthTextureMode.None;

                _depthCamCamera.transform.parent = incore.farCamera.transform;

//				_depthCam.camera.enabled = true;
                _depthCamCamera.enabled = false;



                depthShader = ShaderTool.GetShader2("CompiledDepthTexture.shader");


                if (incore.useGodrays)
                {
                    GodrayDepthShader = ShaderTool.GetShader2("CompiledGodrayDepthTexture.shader");
                }
            }

            _depthCamCamera.CopyFrom(inCamera);
            _depthCamCamera.enabled = false;

            //_depthCam.camera.backgroundColor = new Color(0,0,0,0);
            //_depthCam.camera.clearFlags = CameraClearFlags.SolidColor;

            //inCamera.camera.SetReplacementShader(depthShader,"RenderType");

            //disable rendering of the custom depth buffer when away from PQS

            bool renderDepthBuffer = false;

            if (FlightGlobals.ActiveVessel)
            {
                if (FlightGlobals.ActiveVessel.orbit.referenceBody.pqsController)
                {
                    renderDepthBuffer = FlightGlobals.ActiveVessel.orbit.referenceBody.pqsController.isActive;
                }
            }

            renderDepthBuffer = renderDepthBuffer || incore.pqsEnabled;

//			if (incore.pqsEnabled)   //change this to render at any PQS
            if (renderDepthBuffer)
            {
                //for some reason in KSP this camera wouldn't clear the texture before rendering to it, resulting in a trail effect
                //this snippet fixes that. We need the texture cleared to full white to mask the sky
                RenderTexture rt = RenderTexture.active;
                RenderTexture.active = _depthTex;
                GL.Clear(false, true, Color.white);
                //needed only with Rfloat rendertexture (for godray)
                //not needed for built-in depth


                _depthCamCamera.targetTexture = _depthTex;
//				_depthCam.camera.SetReplacementShader (depthShader, "RenderType");

////				_depthCamCamera.RenderWithShader (depthShader, "RenderType");
//				_depthCamCamera.RenderWithShader (depthShader, "");

                if (!incore.ignoreRenderTypetags)
                {
                    _depthCamCamera.RenderWithShader(depthShader, "RenderType");
                }
                else
                {
                    _depthCamCamera.RenderWithShader(depthShader, "");
                }


                depthTextureCleared = false;

                if (incore.useGodrays)
                {
                    RenderTexture.active = _godrayDepthTex;
                    GL.Clear(false, true, Color.white);


                    _depthCamCamera.targetTexture = _godrayDepthTex;
//					_depthCam.camera.SetReplacementShader (GodrayDepthShader, "RenderType");

////					_depthCamCamera.RenderWithShader (GodrayDepthShader, "RenderType");
//					_depthCamCamera.RenderWithShader (GodrayDepthShader, "");

                    if (!incore.ignoreRenderTypetags)
                    {
                        _depthCamCamera.RenderWithShader(GodrayDepthShader, "RenderType");
                    }
                    else
                    {
                        _depthCamCamera.RenderWithShader(GodrayDepthShader, "");
                    }
                }

                RenderTexture.active = rt;
            }
        }