/// <summary>
        ///    Updates the automatic parameters (except lights) based on the details provided.
        /// </summary>
        /// <param name="source">
        ///    A source containing all the updated data to be made available for auto updating
        ///    the GPU program constants.
        /// </param>
        public void UpdateAutoParamsNoLights(AutoParamDataSource source)
        {
            // return if no constants
            if(!this.HasAutoConstants) {
                return;
            }

            // loop through and update all constants based on their type
            for(int i = 0; i < autoConstantList.Count; i++) {
                AutoConstantEntry entry = (AutoConstantEntry)autoConstantList[i];

                Matrix4[] matrices = null;
                int numMatrices = 0;
                int index = 0;
                float t;

                switch(entry.type) {
                    case AutoConstants.WorldMatrix:
                        SetConstant(entry.index, source.WorldMatrix);
                        break;

                    case AutoConstants.InverseWorldMatrix:
                        SetConstant(entry.index, source.InverseWorldMatrix);
                        break;

                    case AutoConstants.TransposeWorldMatrix:
                        SetConstant(entry.index, source.WorldMatrix.Transpose());
                        break;

                    case AutoConstants.InverseTransposeWorldMatrix:
                        SetConstant(entry.index, source.InverseWorldMatrix.Transpose());
                        break;

                    case AutoConstants.WorldMatrixArray3x4:
                        matrices = source.WorldMatrixArray;
                        numMatrices = source.WorldMatrixCount;
                        index = entry.index;

                        for(int j = 0; j < numMatrices; j++) {
                            Matrix4 m = matrices[j];
                            SetConstant(index++, m.m00, m.m01, m.m02, m.m03);
                            SetConstant(index++, m.m10, m.m11, m.m12, m.m13);
                            SetConstant(index++, m.m20, m.m21, m.m22, m.m23);
                        }

                        break;

                    case AutoConstants.WorldMatrixArray:
                        SetConstant(entry.index, source.WorldMatrixArray, source.WorldMatrixCount);
                        break;

                    case AutoConstants.ViewMatrix:
                        SetConstant(entry.index, source.ViewMatrix);
                        break;

                    case AutoConstants.InverseViewMatrix:
                        SetConstant(entry.index, source.InverseViewMatrix);
                        break;

                    case AutoConstants.TransposeViewMatrix:
                        SetConstant(entry.index, source.ViewMatrix.Transpose());
                        break;

                    case AutoConstants.InverseTransposeViewMatrix:
                        SetConstant(entry.index, source.InverseViewMatrix.Transpose());
                        break;

                    case AutoConstants.ProjectionMatrix:
                        SetConstant(entry.index, source.ProjectionMatrix);
                        break;

                    case AutoConstants.InverseProjectionMatrix:
                        SetConstant(entry.index, source.InverseProjectionMatrix);
                        break;

                    case AutoConstants.InverseTransposeProjectionMatrix:
                        SetConstant(entry.index, source.InverseProjectionMatrix.Transpose());
                        break;

                    case AutoConstants.ViewProjMatrix:
                        SetConstant(entry.index, source.ViewProjectionMatrix);
                        break;

                    case AutoConstants.InverseViewProjMatrix:
                        SetConstant(entry.index, source.InverseViewProjMatrix);
                        break;

                    case AutoConstants.TransposeViewProjMatrix:
                        SetConstant(entry.index, source.ViewProjectionMatrix.Transpose());
                        break;

                    case AutoConstants.InverseTransposeViewProjMatrix:
                        SetConstant(entry.index, source.InverseViewProjMatrix.Transpose());
                        break;

                    case AutoConstants.WorldViewMatrix:
                        SetConstant(entry.index, source.WorldViewMatrix);
                        break;

                    case AutoConstants.InverseWorldViewMatrix:
                        SetConstant(entry.index, source.InverseWorldViewMatrix);
                        break;

                    case AutoConstants.TransposeWorldViewMatrix:
                        SetConstant(entry.index, source.WorldViewMatrix.Transpose());
                        break;

                    case AutoConstants.InverseTransposeWorldViewMatrix:
                        SetConstant(entry.index, source.InverseWorldViewMatrix.Transpose());
                        break;

                    case AutoConstants.RenderTargetFlipping:
                        SetIntConstant(entry.index, source.RenderTarget.RequiresTextureFlipping ? -1 : 1);
                        break;

                    case AutoConstants.AmbientLightColor:
                        SetConstant(entry.index, source.AmbientLight);
                        break;

                    case AutoConstants.DerivedAmbientLightColor:
                        SetConstant(entry.index, source.DerivedAmbientLight);
                        break;

                    case AutoConstants.DerivedSceneColor:
                        ColorEx result = source.DerivedAmbientLight + source.CurrentPass.Emissive;
                        result.a = source.CurrentPass.Diffuse.a;
                        SetConstant(entry.index, result);
                        break;

                    case AutoConstants.FogColor:
                        SetConstant(entry.index, source.FogColor);
                        break;

                    case AutoConstants.FogParams:
                        SetConstant(entry.index, source.FogParams);
                        break;

                    case AutoConstants.SurfaceAmbientColor:
                        SetConstant(entry.index, source.CurrentPass.Ambient);
                        break;

                    case AutoConstants.SurfaceDiffuseColor:
                        SetConstant(entry.index, source.CurrentPass.Diffuse);
                        break;

                    case AutoConstants.SurfaceSpecularColor:
                        SetConstant(entry.index, source.CurrentPass.Specular);
                        break;

                    case AutoConstants.SurfaceEmissiveColor:
                        SetConstant(entry.index, source.CurrentPass.Emissive);
                        break;

                    case AutoConstants.SurfaceShininess:
                        SetConstant(entry.index, source.CurrentPass.Shininess);
                        break;

                    case AutoConstants.CameraPosition:
                        SetConstant(entry.index, source.CameraPosition);
                        break;

                    case AutoConstants.CameraPositionObjectSpace:
                        SetConstant(entry.index, source.CameraPositionObjectSpace);
                        break;

                    case AutoConstants.Time:
                        SetFloatConstant(entry.index, source.Time * entry.fdata);
                        break;

                    case AutoConstants.Time_0_X:
                        SetFloatConstant(entry.index, source.GetTime_0_X(entry.fdata));
                        break;

                    case AutoConstants.CosTime_0_X:
                        SetFloatConstant(entry.index, (float)Math.Cos(source.GetTime_0_X(entry.fdata)));
                        break;

                    case AutoConstants.SinTime_0_X:
                        SetFloatConstant(entry.index, (float)Math.Sin(source.GetTime_0_X(entry.fdata)));
                        break;

                    case AutoConstants.TanTime_0_X:
                        SetFloatConstant(entry.index, (float)Math.Tan(source.GetTime_0_X(entry.fdata)));
                        break;

                    case AutoConstants.Time_0_X_Packed:
                        t = source.Time;
                        SetConstant(entry.index, t, (float)Math.Sin(t), (float)Math.Cos(t), (float)Math.Tan(t));
                        break;

                    case AutoConstants.Time_0_1:
                        SetFloatConstant(entry.index, source.GetTime_0_1(entry.fdata));
                        break;

                    case AutoConstants.CosTime_0_1:
                        SetFloatConstant(entry.index, (float)Math.Cos(source.GetTime_0_1(entry.fdata)));
                        break;

                    case AutoConstants.SinTime_0_1:
                        SetFloatConstant(entry.index, (float)Math.Sin(source.GetTime_0_1(entry.fdata)));
                        break;

                    case AutoConstants.TanTime_0_1:
                        SetFloatConstant(entry.index, (float)Math.Tan(source.GetTime_0_1(entry.fdata)));
                        break;

                    case AutoConstants.Time_0_1_Packed:
                        t = source.GetTime_0_1(entry.fdata);
                        SetConstant(entry.index, t, (float)Math.Sin(t), (float)Math.Cos(t), (float)Math.Tan(t));
                        break;

                    case AutoConstants.Time_0_2PI:
                        SetFloatConstant(entry.index, source.GetTime_0_2PI(entry.fdata));
                        break;

                    case AutoConstants.CosTime_0_2PI:
                        SetFloatConstant(entry.index, (float)Math.Cos(source.GetTime_0_2PI(entry.fdata)));
                        break;

                    case AutoConstants.SinTime_0_2PI:
                        SetFloatConstant(entry.index, (float)Math.Sin(source.GetTime_0_2PI(entry.fdata)));
                        break;

                    case AutoConstants.TanTime_0_2PI:
                        SetFloatConstant(entry.index, (float)Math.Tan(source.GetTime_0_2PI(entry.fdata)));
                        break;

                    case AutoConstants.Time_0_2PI_Packed:
                        t = source.GetTime_0_2PI(entry.fdata);
                        SetConstant(entry.index, t, (float)Math.Sin(t), (float)Math.Cos(t), (float)Math.Tan(t));
                        break;

                    case AutoConstants.FrameTime:
                        SetConstant(entry.index, (1.0f / Root.Instance.AverageFPS));
                        break;

                    case AutoConstants.FPS:
                        SetConstant(entry.index, Root.Instance.AverageFPS);
                        break;

                    case AutoConstants.ViewportWidth:
                        SetConstant(entry.index, source.Viewport.ActualWidth);
                        break;

                    case AutoConstants.ViewportHeight:
                        SetConstant(entry.index, source.Viewport.ActualHeight);
                        break;

                    case AutoConstants.ViewportSize:
                        SetConstant(entry.index,
                                    new Vector4(source.Viewport.ActualWidth,
                                                source.Viewport.ActualHeight,
                                                1.0f / source.Viewport.ActualWidth,
                                                1.0f / source.Viewport.ActualHeight));
                        break;

                    case AutoConstants.TexelOffsets:
                        RenderSystem rsys = Root.Instance.RenderSystem;
                        SetConstant(entry.index,
                            new Vector4(rsys.HorizontalTexelOffset,
                                        rsys.VerticalTexelOffset,
                                        rsys.HorizontalTexelOffset / source.Viewport.ActualWidth,
                                        rsys.VerticalTexelOffset / source.Viewport.ActualHeight));
                        break;

                    case AutoConstants.TextureSize:
                        SetConstant(entry.index, source.GetTextureSize(entry.data));
                        break;

                    case AutoConstants.InverseTextureSize:
                        SetConstant(entry.index, 1.0f / source.GetTextureSize(entry.data));
                        break;

                    case AutoConstants.SceneDepthRange:
                        SetConstant(entry.index, source.SceneDepthRange);
                        break;

                    case AutoConstants.ViewDirection:
                        SetConstant(entry.index, source.ViewDirection);
                        break;

                    case AutoConstants.ViewSideVector:
                        SetConstant(entry.index, source.ViewSideVector);
                        break;

                    case AutoConstants.WorldViewProjMatrix:
                        SetConstant(entry.index, source.WorldViewProjMatrix);
                        break;

                    case AutoConstants.ViewUpVector:
                        SetConstant(entry.index, source.ViewUpVector);
                        break;

                    case AutoConstants.FOV:
                        SetConstant(entry.index, MathUtil.DegreesToRadians(source.Camera.FOVy));
                        break;

                    case AutoConstants.NearClipDistance:
                        SetConstant(entry.index, source.NearClipDistance);
                        break;

                    case AutoConstants.FarClipDistance:
                        SetConstant(entry.index, source.FarClipDistance);
                        break;

                    case AutoConstants.PassNumber:
                        SetIntConstant(entry.index, source.PassNumber);
                        break;

                    case AutoConstants.PassIterationNumber:
                        // TODO: This isn't right, and doesn't match
                        // what Ogre does.  I can't figure out what
                        // Ogre does.
                        SetIntConstant(entry.index, source.PassIterationNumber);
                        break;

                    case AutoConstants.TextureViewProjMatrix:
                        SetConstant(entry.index, source.GetTextureViewProjectionMatrix(entry.data));
                        break;

                    case AutoConstants.Custom:
                    case AutoConstants.AnimationParametric:
                        source.Renderable.UpdateCustomGpuParameter(entry, this);
                        break;

                    case AutoConstants.MVShadowTechnique:
                        SetConstant(entry.index, source.MVShadowTechnique);
                        break;

                    case AutoConstants.ShadowFadeParams:
                        SetConstant(entry.index, source.ShadowFadeParams);
                        break;
                }
            }
        }