/// <summary>
        /// Builds a 3D lookup texture containing the scattering values for a parameterization of
        /// the view frame and sun position.
        /// </summary>
        /// <param name="parameters">Parameters for the build process</param>
        /// <param name="progress">Progress object</param>
        /// <param name="voxels">3d texture voxels</param>
        /// <returns>true if build completed (wasn't cancelled)</returns>
        private unsafe bool BuildScatteringTexture( AtmosphereBuildParameters parameters, byte* voxels, AtmosphereBuildProgress progress )
        {
            float viewAngle = Constants.Pi;
            float viewAngleInc = Constants.Pi  / ( parameters.ViewAngleSamples - 1 );
            float heightRange = ( m_OuterRadius - m_InnerRadius );
            float heightInc = ( heightRange * 0.9999f ) / ( parameters.HeightSamples - 1 );	//	Push height range in slightly to allow simplification of sphere intersections
            float sunAngleInc = ( Constants.Pi ) / ( parameters.SunAngleSamples - 1 );

            for ( int viewAngleSample = 0; viewAngleSample < parameters.ViewAngleSamples; ++viewAngleSample, viewAngle -= viewAngleInc )
            {
                Vector3 viewDir = new Vector3( Functions.Sin( viewAngle ), Functions.Cos( viewAngle ), 0 );

                float sunAngle = 0;
                for ( int sunAngleSample = 0; sunAngleSample < parameters.SunAngleSamples; ++sunAngleSample, sunAngle += sunAngleInc )
                {
                    Vector3 sunDir = new Vector3( Functions.Sin( sunAngle ), Functions.Cos( sunAngle ), 0 );
                    float height = m_InnerRadius;
                    for ( int heightSample = 0; heightSample < parameters.HeightSamples; ++heightSample, height += heightInc )
                    {
                        ComputeScattering( viewDir, sunDir, height, voxels );
                        voxels += 4;
                    }
                }

                if ( progress != null )
                {
                    progress.OnSliceCompleted( viewAngleSample / ( float )( parameters.ViewAngleSamples - 1 ) );

                    if ( progress.Cancel )
                    {
                        return false;
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// Builds a 2D lookup texture containing optical depth for a paramerization of the view frame
        /// </summary>
        /// <param name="buildParams">Atmosphere build parameters</param>
        /// <param name="pixels">Atmosphere texture pixels</param>
        /// <param name="progress">Progress indicator</param>
        /// <returns>Returns true if the build completed (wasn't cancelled)</returns>
        private unsafe bool BuildOpticalDepthTexture( AtmosphereBuildParameters buildParams, byte* pixels, AtmosphereBuildProgress progress )
        {
            //	TODO: AP: Because we know that the view to pos angle range will never be > pi, can optimise this later
            int viewSamples = buildParams.OpticalDepthResolution;
            int heightSamples = buildParams.OpticalDepthResolution;
            float viewAngleInc = Constants.Pi / ( viewSamples - 1 );
            float heightRange = ( m_OuterRadius - m_InnerRadius );
            float heightInc = ( heightRange * 0.9999f ) / ( heightSamples - 1 );	//	Push height range in slightly to allow simplification of sphere intersections

            float* rAccum = stackalloc float[ 3 ];
            float* mAccum = stackalloc float[ 3 ];
            float height = m_InnerRadius;
            for ( int heightSample = 0; heightSample < heightSamples; ++heightSample, height += heightInc )
            {
                Point3 pos = new Point3( 0, height, 0 );
                //	Start the view angle at pi, and count down to 0. This is because it is quickest to address
                //	the 2D texture using the dot of the view vector and the view position, saving a (1-th) operation
                float viewAngle = Constants.Pi;
                Point3 lastAtmInt = pos;
                for ( int viewSample = 0; viewSample < viewSamples; ++viewSample, viewAngle -= viewAngleInc )
                {
                    Vector3 viewDir = new Vector3( Functions.Sin( viewAngle ), Functions.Cos( viewAngle ), 0 );

                    //	NOTE: If ray intersection fails, the previous intersection position is used...
                    Point3 atmInt;
                //	if ( !GetRayPlanetAndAtmosphereIntersection( pos, viewDir, out atmInt ) )
                    if ( !GetRayAtmosphereIntersection( pos, viewDir, out atmInt ) )
                    {
                        atmInt = lastAtmInt;
                    }
                    else
                    {
                        lastAtmInt = atmInt;
                    }

                    Vector3 step = ( atmInt - pos ) / m_AttenuationSamples;

                    rAccum[ 0 ] = rAccum[ 1 ] = rAccum[ 2 ] = 0;
                    mAccum[ 0 ] = mAccum[ 1 ] = mAccum[ 2 ] = 0;
                    CalculateOutScatter( pos, step, rAccum, mAccum );

                //	float oR = CalculateCombinedOutScatter( pos, step, m_RayleighCoefficients[ 0 ], m_MieCoefficients[ 0 ] );
                //	float oG = CalculateCombinedOutScatter( pos, step, m_RayleighCoefficients[ 1 ], m_MieCoefficients[ 1 ] );
                //	float oB = CalculateCombinedOutScatter( pos, step, m_RayleighCoefficients[ 2 ], m_MieCoefficients[ 2 ] );

                    float attR = ExtinctionCoefficient( rAccum[ 0 ], mAccum[ 0 ] );
                    float attG = ExtinctionCoefficient( rAccum[ 1 ], mAccum[ 1 ] );
                    float attB = ExtinctionCoefficient( rAccum[ 2 ], mAccum[ 2 ] );

                    pixels[ 2 ] = ( byte )( Utils.Clamp( attR, 0, 1 ) * 255.0f );
                    pixels[ 1 ] = ( byte )( Utils.Clamp( attG, 0, 1 ) * 255.0f );
                    pixels[ 0 ] = ( byte )( Utils.Clamp( attB, 0, 1 ) * 255.0f );
                    pixels += 3;
                }

                if ( progress != null )
                {
                    progress.OnSliceCompleted( heightSample / ( float )( heightSamples - 1 ) );
                    if ( progress.Cancel )
                    {
                        return false;
                    }
                }
            }
            return true;
        }