Exemplo n.º 1
0
        /// <summary>
        /// This sets a texture ONLY if it has changed (i.e. not the same or content is dirty)
        /// </summary>
        /// <param name="_Name"></param>
        /// <param name="_Value"></param>
        /// <param name="_bClearDirtyFlag">True to mark the texture as "clean" once assigned</param>
        public static void SetGlobalTexture( string _Name, NuajTexture2D _Value, bool _bClearDirtyFlag )
        {
            NuajTexture2D	CurrentTexture = ms_GlobalParamName2Texture.ContainsKey( _Name ) ? ms_GlobalParamName2Texture[_Name] : null;
            if ( _Value == CurrentTexture && _Value != null && !_Value.IsDirty )
                return;	// No change in texture or content...

            ms_GlobalParamName2Texture[_Name] = _Value;	// Update to new texture

            // Upload...
            Shader.SetGlobalTexture( _Name, _Value != null ? _Value.Texture : null );

            if ( _bClearDirtyFlag && _Value != null )
                _Value.IsDirty = false;	// This texture has been uploaded so it's not dirty anymore...

            // Notify
            Help.LogDebugWarning( "Texture \"" + (_Value != null && _Value.Texture ? _Value.Texture.name : "null") + "\" has been uploaded as GLOBAL \"" + _Name + "\"" );
        }
Exemplo n.º 2
0
        /// <summary>
        /// Builds the table containing the Mie phase function
        /// </summary>
        protected void BuildPhaseFunction( double[] _PhaseFunction )
        {
            // Compute MIN/MAX indices of the phase function
            int		MinIndex = Mathf.FloorToInt( _PhaseFunction.Length * PHASE_START_ANGLE / Mathf.PI );
            int		MaxIndex = Mathf.FloorToInt( (_PhaseFunction.Length-1) * PHASE_END_ANGLE / Mathf.PI );

            // Compute integral of provided function
            double	fIntegral = 0.0;
            for ( int Index=0; Index < PHASE_TEXTURE_SIZE; Index++ )
            {
                int	OriginalPhaseIndex = MinIndex + (MaxIndex - MinIndex) * Index / (PHASE_TEXTURE_SIZE-1);
                fIntegral += _PhaseFunction[OriginalPhaseIndex];
            }

            fIntegral *= Math.PI / PHASE_TEXTURE_SIZE;	// * dTheta
            fIntegral *= 2.0 * Math.PI;
            fIntegral = 1.0 / fIntegral;

            // Copy source function into collapsed table
            float[]	PhaseFactors = new float[PHASE_TEXTURE_SIZE];
            double	IntegralCheck = 0.0;
            for ( int Index=0; Index < PHASE_TEXTURE_SIZE; Index++ )
            {
                int		OriginalPhaseIndex = MinIndex + (MaxIndex - MinIndex) * Index / PHASE_TEXTURE_SIZE;
                PhaseFactors[Index] = (float) (_PhaseFunction[OriginalPhaseIndex] * fIntegral);

                IntegralCheck += PhaseFactors[Index];
            }
            IntegralCheck *= Math.PI / PHASE_TEXTURE_SIZE;	// * dTheta
            IntegralCheck *= 2.0 * Math.PI;

            // Create phase function for 0- and single-scattering
            Color[]	Pixels = new Color[PHASE_TEXTURE_SIZE];
            for ( int i=0; i < PHASE_TEXTURE_SIZE; i++ )
            {
                float	Value = PhaseFactors[i] * 256.0f;
                float	R = Mathf.Floor( Value );
                float	G = Value - R;
                Pixels[i] = new Color( R / 256.0f, G, 0.0f, 0.0f );
            }

            // Build the convolved phase function for double-scattering
            double[]	PhaseConvolved = new double[PHASE_TEXTURE_SIZE];
            double		DeltaAngle = Math.PI / PHASE_TEXTURE_SIZE;
            for ( int AngleIndex0=0; AngleIndex0 < PHASE_TEXTURE_SIZE; AngleIndex0++ )
            {
                double	Phase0 = PhaseFactors[AngleIndex0];
                double	Convolution = 0.0;
                for ( int AngleIndex1=0; AngleIndex1 < PHASE_TEXTURE_SIZE; AngleIndex1++ )
                    Convolution += Phase0 * PhaseFactors[(PHASE_TEXTURE_SIZE + AngleIndex0 - AngleIndex1) % PHASE_TEXTURE_SIZE];

                PhaseConvolved[AngleIndex0] = (float) (DeltaAngle * Convolution);
            }

            for ( int i=0; i < PHASE_TEXTURE_SIZE; i++ )
            {
                float	Value = (float) (PhaseConvolved[i] * 256.0);
                float	B = Mathf.Floor( Value );
                float	A = Value - B;
                Pixels[i].b = B / 256.0f;
                Pixels[i].a = A;
            }

            // Build texture
            m_TexturePhase = Help.CreateTexture( "Layered Clouds Phase Function", PHASE_TEXTURE_SIZE, 1, TextureFormat.ARGB32, false, FilterMode.Bilinear, TextureWrapMode.Clamp );
            m_TexturePhase.SetPixels( 0, 0, PHASE_TEXTURE_SIZE, 1, Pixels, 0 );
            m_TexturePhase.Apply();
        }