UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source, Core.Collections.LightList lightList ) { if ( this.reflectionPowerChanged ) { GpuProgramParameters fsParams = pass.FragmentProgramParameters; this.reflectionPower.SetGpuParameter( this.reflectionPowerValue ); this.reflectionPowerChanged = false; } }
public override void UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source, Core.Collections.LightList lightList ) { if ( this.fogMode == FogMode.None ) { return; } FogMode fMode; ColorEx newFogColor; Real newFogStart, newFogEnd, newFogDensity; if ( this.passOverrideParams ) { fMode = pass.FogMode; newFogColor = pass.FogColor; newFogStart = pass.FogStart; newFogEnd = pass.FogEnd; newFogDensity = pass.FogDensity; } else { var sceneMgr = ShaderGenerator.Instance.ActiveSceneManager; fMode = sceneMgr.FogMode; newFogColor = sceneMgr.FogColor; newFogStart = sceneMgr.FogStart; newFogEnd = sceneMgr.FogEnd; newFogDensity = sceneMgr.FogDensity; } SetFogProperties( fMode, newFogColor, newFogStart, newFogEnd, newFogDensity ); //Per pixel fog if ( this.calcMode == CalcMode.PerPixel ) { this.fogParams.SetGpuParameter( this.fogParamsValue ); } //per vertex fog else { this.fogParams.SetGpuParameter( this.fogParamsValue ); } this.fogColor.SetGpuParameter( this.fogColorValue ); }
public override void UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source, Core.Collections.LightList lightList ) { for ( int i = 0; i < this.textureUnitParamsList.Count; i++ ) { TextureUnitParams curParams = this.textureUnitParamsList[ i ]; if ( curParams.TextureProjector != null && curParams.TextureViewProjImageMatrix != null ) { Matrix4 matTexViewProjImage; matTexViewProjImage = Matrix4.ClipSpace2DToImageSpace* curParams.TextureProjector.ProjectionMatrixRSDepth* curParams.TextureProjector.ViewMatrix; curParams.TextureViewProjImageMatrix.SetGpuParameter( matTexViewProjImage ); } } }
/// <summary> /// /// </summary> /// <param name="disposeManagedResources"></param> protected override void dispose( bool disposeManagedResources ) { if ( !this.IsDisposed ) { if ( disposeManagedResources ) { this.ClearScene(); this.RemoveAllCameras(); if ( op != null ) { if ( !op.IsDisposed ) op.Dispose(); op = null; } if ( this.autoParamDataSource != null ) { if ( !this.autoParamDataSource.IsDisposed ) this.autoParamDataSource.Dispose(); this.autoParamDataSource = null; } if ( this.rootSceneNode != null ) { if ( !this.rootSceneNode.IsDisposed ) this.rootSceneNode.Dispose(); this.rootSceneNode = null; } } } base.dispose( disposeManagedResources ); }
public void UpdateAutoParams( AutoParamDataSource source, GpuParamVariability mask ) { // abort early if no autos if ( !HasAutoConstantType ) { return; } if ( ( mask & this._combinedVariability ) == 0 ) { return; } this.activePassIterationIndex = int.MaxValue; Matrix3 m3; Vector4 vec4; Vector3 vec3; // loop through and update all constants based on their type foreach ( var entry in this.autoConstants ) { // Only update needed slots if ( ( entry.Variability & mask ) == 0 ) { continue; } switch ( entry.Type ) { case AutoConstantType.ViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.ViewMatrix, entry.ElementCount ); break; case AutoConstantType.InverseViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseViewMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeViewMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeViewMatrix, entry.ElementCount ); break; case AutoConstantType.ProjectionMatrix: WriteRawConstant( entry.PhysicalIndex, source.ProjectionMatrix, entry.ElementCount ); break; case AutoConstantType.InverseProjectionMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseProjectionMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeProjectionMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeProjectionMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeProjectionMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeProjectionMatrix, entry.ElementCount ); break; case AutoConstantType.ViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.ViewProjectionMatrix, entry.ElementCount ); break; case AutoConstantType.InverseViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.RenderTargetFlipping: WriteRawConstant( entry.PhysicalIndex, source.CurrentRenderTarget.RequiresTextureFlipping ? -1.0f : 1.0f ); break; case AutoConstantType.VertexWinding: { var rsys = Root.Instance.RenderSystem; WriteRawConstant( entry.PhysicalIndex, rsys.InvertVertexWinding ? -1.0f : 1.0f ); break; } // NB ambient light still here because it's not related to a specific light case AutoConstantType.AmbientLightColor: WriteRawConstant( entry.PhysicalIndex, source.AmbientLight, entry.ElementCount ); break; case AutoConstantType.DerivedAmbientLightColor: WriteRawConstant( entry.PhysicalIndex, source.DerivedAmbient, entry.ElementCount ); break; case AutoConstantType.DerivedSceneColor: WriteRawConstant( entry.PhysicalIndex, source.DerivedSceneColor, entry.ElementCount ); break; case AutoConstantType.FogColor: WriteRawConstant( entry.PhysicalIndex, source.FogColor ); break; case AutoConstantType.FogParams: WriteRawConstant( entry.PhysicalIndex, source.FogParams, entry.ElementCount ); break; case AutoConstantType.SurfaceAmbientColor: WriteRawConstant( entry.PhysicalIndex, source.SurfaceAmbient, entry.ElementCount ); break; case AutoConstantType.SurfaceDiffuseColor: WriteRawConstant( entry.PhysicalIndex, source.SurfaceDiffuse, entry.ElementCount ); break; case AutoConstantType.SurfaceSpecularColor: WriteRawConstant( entry.PhysicalIndex, source.SurfaceSpecular, entry.ElementCount ); break; case AutoConstantType.SurfaceEmissiveColor: WriteRawConstant( entry.PhysicalIndex, source.SurfaceEmissive, entry.ElementCount ); break; case AutoConstantType.SurfaceShininess: WriteRawConstant( entry.PhysicalIndex, source.SurfaceShininess ); break; case AutoConstantType.CameraPosition: WriteRawConstant( entry.PhysicalIndex, source.CameraPosition, entry.ElementCount ); break; case AutoConstantType.Time: WriteRawConstant( entry.PhysicalIndex, source.Time*entry.FData ); break; case AutoConstantType.Time_0_X: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_X( entry.FData ) ); break; case AutoConstantType.CosTime_0_X: WriteRawConstant( entry.PhysicalIndex, source.GetCosTime_0_X( entry.FData ) ); break; case AutoConstantType.SinTime_0_X: WriteRawConstant( entry.PhysicalIndex, source.GetSinTime_0_X( entry.FData ) ); break; case AutoConstantType.TanTime_0_X: WriteRawConstant( entry.PhysicalIndex, source.GetTanTime_0_X( entry.FData ) ); break; case AutoConstantType.Time_0_X_Packed: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_X_Packed( entry.FData ), entry.ElementCount ); break; case AutoConstantType.Time_0_1: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_1( entry.FData ) ); break; case AutoConstantType.CosTime_0_1: WriteRawConstant( entry.PhysicalIndex, source.GetCosTime_0_1( entry.FData ) ); break; case AutoConstantType.SinTime_0_1: WriteRawConstant( entry.PhysicalIndex, source.GetSinTime_0_1( entry.FData ) ); break; case AutoConstantType.TanTime_0_1: WriteRawConstant( entry.PhysicalIndex, source.GetTanTime_0_1( entry.FData ) ); break; case AutoConstantType.Time_0_1_Packed: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_1_Packed( entry.FData ), entry.ElementCount ); break; case AutoConstantType.Time_0_2PI: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_2Pi( entry.FData ) ); break; case AutoConstantType.CosTime_0_2PI: WriteRawConstant( entry.PhysicalIndex, source.GetCosTime_0_2Pi( entry.FData ) ); break; case AutoConstantType.SinTime_0_2PI: WriteRawConstant( entry.PhysicalIndex, source.GetSinTime_0_2Pi( entry.FData ) ); break; case AutoConstantType.TanTime_0_2PI: WriteRawConstant( entry.PhysicalIndex, source.GetTanTime_0_2Pi( entry.FData ) ); break; case AutoConstantType.Time_0_2PI_Packed: WriteRawConstant( entry.PhysicalIndex, source.GetTime_0_2Pi_Packed( entry.FData ), entry.ElementCount ); break; case AutoConstantType.FrameTime: WriteRawConstant( entry.PhysicalIndex, source.FrameTime*entry.FData ); break; case AutoConstantType.FPS: WriteRawConstant( entry.PhysicalIndex, source.FPS ); break; case AutoConstantType.ViewportWidth: WriteRawConstant( entry.PhysicalIndex, source.ViewportWidth ); break; case AutoConstantType.ViewportHeight: WriteRawConstant( entry.PhysicalIndex, source.ViewportHeight ); break; case AutoConstantType.InverseViewportWidth: WriteRawConstant( entry.PhysicalIndex, source.InverseViewportWidth ); break; case AutoConstantType.InverseViewportHeight: WriteRawConstant( entry.PhysicalIndex, source.InverseViewportHeight ); break; case AutoConstantType.ViewportSize: { WriteRawConstant( entry.PhysicalIndex, new Vector4( source.ViewportWidth, source.ViewportHeight, source.InverseViewportWidth, source.InverseViewportHeight ), entry.ElementCount ); } break; case AutoConstantType.TexelOffsets: { var rsys = Root.Instance.RenderSystem; WriteRawConstant( entry.PhysicalIndex, new Vector4( rsys.HorizontalTexelOffset, rsys.VerticalTexelOffset, rsys.HorizontalTexelOffset*source.InverseViewportWidth, rsys.VerticalTexelOffset*source.InverseViewportHeight ), entry.ElementCount ); } break; case AutoConstantType.TextureSize: WriteRawConstant( entry.PhysicalIndex, source.GetTextureSize( entry.Data ), entry.ElementCount ); break; case AutoConstantType.InverseTextureSize: WriteRawConstant( entry.PhysicalIndex, source.GetInverseTextureSize( entry.Data ), entry.ElementCount ); break; case AutoConstantType.PackedTextureSize: WriteRawConstant( entry.PhysicalIndex, source.GetPackedTextureSize( entry.Data ), entry.ElementCount ); break; case AutoConstantType.SceneDepthRange: WriteRawConstant( entry.PhysicalIndex, source.SceneDepthRange, entry.ElementCount ); break; case AutoConstantType.ViewDirection: WriteRawConstant( entry.PhysicalIndex, source.ViewDirection ); break; case AutoConstantType.ViewSideVector: WriteRawConstant( entry.PhysicalIndex, source.ViewSideVector ); break; case AutoConstantType.ViewUpVector: WriteRawConstant( entry.PhysicalIndex, source.ViewUpVector ); break; case AutoConstantType.FOV: WriteRawConstant( entry.PhysicalIndex, source.FOV ); break; case AutoConstantType.NearClipDistance: WriteRawConstant( entry.PhysicalIndex, source.NearClipDistance ); break; case AutoConstantType.FarClipDistance: WriteRawConstant( entry.PhysicalIndex, source.FarClipDistance ); break; case AutoConstantType.PassNumber: WriteRawConstant( entry.PhysicalIndex, (float)source.PassNumber ); break; case AutoConstantType.PassIterationNumber: { // this is actually just an initial set-up, it's bound separately, so still global WriteRawConstant( entry.PhysicalIndex, 0.0f ); this.activePassIterationIndex = entry.PhysicalIndex; } break; case AutoConstantType.TextureMatrix: WriteRawConstant( entry.PhysicalIndex, source.GetTextureTransformMatrix( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LODCameraPosition: WriteRawConstant( entry.PhysicalIndex, source.LodCameraPosition, entry.ElementCount ); break; case AutoConstantType.TextureWorldViewProjMatrix: // can also be updated in lights WriteRawConstant( entry.PhysicalIndex, source.GetTextureWorldViewProjMatrix( entry.Data ), entry.ElementCount ); break; case AutoConstantType.TextureWorldViewProjMatrixArray: for ( var l = 0; l < entry.Data; ++l ) { // can also be updated in lights WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetTextureWorldViewProjMatrix( l ), entry.ElementCount ); } break; case AutoConstantType.SpotLightWorldViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.GetSpotlightWorldViewProjMatrix( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightPositionObjectSpace: { vec4 = source.GetLightAs4DVector( entry.Data ); vec3 = new Vector3( vec4.x, vec4.y, vec4.z ); if ( vec4.w > 0.0f ) { // point light vec3 = source.InverseWorldMatrix.TransformAffine( vec3 ); } else { // directional light // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix( out m3 ); vec3 = ( m3*vec3 ).ToNormalized(); } WriteRawConstant( entry.PhysicalIndex, new Vector4( vec3.x, vec3.y, vec3.z, vec4.w ), entry.ElementCount ); } break; case AutoConstantType.LightDirectionObjectSpace: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix( out m3 ); vec3 = m3*source.GetLightDirection( entry.Data ); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant( entry.PhysicalIndex, new Vector4( vec3.x, vec3.y, vec3.z, 0.0f ), entry.ElementCount ); } break; case AutoConstantType.LightDistanceObjectSpace: { vec3 = source.InverseWorldMatrix.TransformAffine( source.GetLightPosition( entry.Data ) ); WriteRawConstant( entry.PhysicalIndex, vec3.Length ); } break; case AutoConstantType.LightPositionObjectSpaceArray: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix( out m3 ); for ( var l = 0; l < entry.Data; ++l ) { vec4 = source.GetLightAs4DVector( l ); vec3 = new Vector3( vec4.x, vec4.y, vec4.z ); if ( vec4.w > 0.0f ) { // point light vec3 = source.InverseWorldMatrix.TransformAffine( vec3 ); } else { // directional light vec3 = ( m3*vec3 ).ToNormalized(); } WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, new Vector4( vec3.x, vec3.y, vec3.z, vec4.w ), entry.ElementCount ); } } break; case AutoConstantType.LightDirectionObjectSpaceArray: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix( out m3 ); for ( var l = 0; l < entry.Data; ++l ) { vec3 = m3*source.GetLightDirection( l ); vec3.Normalize(); WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, new Vector4( vec3.x, vec3.y, vec3.z, 0.0f ), entry.ElementCount ); } } break; case AutoConstantType.LightDistanceObjectSpaceArray: for ( var l = 0; l < entry.Data; ++l ) { vec3 = source.InverseWorldMatrix.TransformAffine( source.GetLightPosition( l ) ); WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, vec3.Length ); } break; case AutoConstantType.WorldMatrix: WriteRawConstant( entry.PhysicalIndex, source.WorldMatrix, entry.ElementCount ); break; case AutoConstantType.InverseWorldMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseWorldMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeWorldMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeWorldMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeWorldMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeWorldMatrix, entry.ElementCount ); break; case AutoConstantType.WorldMatrixArray3x4: { // Loop over matrices var pMatrix = source.WorldMatrixArray; var numMatrices = source.WorldMatrixCount; var index = entry.PhysicalIndex; var floatArray = new float[16]; for ( var m = 0; m < numMatrices; ++m ) { pMatrix[ m ].MakeFloatArray( floatArray ); _writeRawConstants( index, floatArray, 12 ); index += 12; } } break; case AutoConstantType.WorldMatrixArray: WriteRawConstant( entry.PhysicalIndex, source.WorldMatrixArray, source.WorldMatrixCount ); break; case AutoConstantType.WorldViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.WorldViewMatrix, entry.ElementCount ); break; case AutoConstantType.InverseWorldViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseWorldViewMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeWorldViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeWorldViewMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeWorldViewMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeWorldViewMatrix, entry.ElementCount ); break; case AutoConstantType.WorldViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.WorldViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.InverseWorldViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseWorldViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.TransposeWorldViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.TransposeWorldViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.InverseTransposeWorldViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.InverseTransposeWorldViewProjMatrix, entry.ElementCount ); break; case AutoConstantType.CameraPositionObjectSpace: WriteRawConstant( entry.PhysicalIndex, source.CameraPositionObjectSpace, entry.ElementCount ); break; case AutoConstantType.LODCameraPositionObjectSpace: WriteRawConstant( entry.PhysicalIndex, source.LodCameraPositionObjectSpace, entry.ElementCount ); break; case AutoConstantType.Custom: case AutoConstantType.AnimationParametric: source.CurrentRenderable.UpdateCustomGpuParameter( entry, this ); break; case AutoConstantType.LightCustom: source.UpdateLightCustomGpuParameter( entry, this ); break; case AutoConstantType.LightCount: WriteRawConstant( entry.PhysicalIndex, source.LightCount ); break; case AutoConstantType.LightDiffuseColor: WriteRawConstant( entry.PhysicalIndex, source.GetLightDiffuse( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightSpecularColor: WriteRawConstant( entry.PhysicalIndex, source.GetLightSpecular( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightPosition: { // Get as 4D vector, works for directional lights too // Use element count in case uniform slot is smaller WriteRawConstant( entry.PhysicalIndex, source.GetLightAs4DVector( entry.Data ), entry.ElementCount ); } break; case AutoConstantType.LightDirection: { vec3 = source.GetLightDirection( entry.Data ); // Set as 4D vector for compatibility // Use element count in case uniform slot is smaller WriteRawConstant( entry.PhysicalIndex, new Vector4( vec3.x, vec3.y, vec3.z, 1.0f ), entry.ElementCount ); } break; case AutoConstantType.LightPositionViewSpace: { vec4 = source.GetLightAs4DVector( entry.Data ); WriteRawConstant( entry.PhysicalIndex, source.ViewMatrix.TransformAffine( vec4 ), entry.ElementCount ); } break; case AutoConstantType.LightDirectionViewSpace: { source.InverseTransposeViewMatrix.Extract3x3Matrix( out m3 ); // inverse transpose in case of scaling vec3 = m3*source.GetLightDirection( entry.Data ); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant( entry.PhysicalIndex, new Vector4( vec3.x, vec3.y, vec3.z, 0.0f ), entry.ElementCount ); } break; case AutoConstantType.ShadowExtrusionDistance: { // extrusion is in object-space, so we have to rescale by the inverse // of the world scaling to deal with scaled objects source.WorldMatrix.Extract3x3Matrix( out m3 ); WriteRawConstant( entry.PhysicalIndex, source.ShadowExtrusionDistance/ Utility.Sqrt( Utility.Max( Utility.Max( m3.GetColumn( 0 ).LengthSquared, m3.GetColumn( 1 ).LengthSquared ), m3.GetColumn( 2 ).LengthSquared ) ) ); } break; case AutoConstantType.ShadowSceneDepthRange: WriteRawConstant( entry.PhysicalIndex, source.GetShadowSceneDepthRange( entry.Data ) ); break; case AutoConstantType.ShadowColor: WriteRawConstant( entry.PhysicalIndex, source.ShadowColor, entry.ElementCount ); break; case AutoConstantType.LightPowerScale: WriteRawConstant( entry.PhysicalIndex, source.GetLightPowerScale( entry.Data ) ); break; case AutoConstantType.LightDiffuseColorPowerScaled: WriteRawConstant( entry.PhysicalIndex, source.GetLightDiffuseColorWithPower( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightSpecularColorPowerScaled: WriteRawConstant( entry.PhysicalIndex, source.GetLightSpecularColorWithPower( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightNumber: WriteRawConstant( entry.PhysicalIndex, source.GetLightNumber( entry.Data ) ); break; case AutoConstantType.LightCastsShadows: WriteRawConstant( entry.PhysicalIndex, source.GetLightCastsShadows( entry.Data ) ); break; case AutoConstantType.LightAttenuation: WriteRawConstant( entry.PhysicalIndex, source.GetLightAttenuation( entry.Data ), entry.ElementCount ); break; case AutoConstantType.SpotLightParams: WriteRawConstant( entry.PhysicalIndex, source.GetSpotlightParams( entry.Data ), entry.ElementCount ); break; case AutoConstantType.LightDiffuseColorArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightDiffuse( l ), entry.ElementCount ); } break; case AutoConstantType.LightSpecularColorArray: { for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightSpecular( l ), entry.ElementCount ); } } break; case AutoConstantType.LightDiffuseColorPowerScaledArray: { for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightDiffuseColorWithPower( l ), entry.ElementCount ); } } break; case AutoConstantType.LightSpecularColorPowerScaledArray: { for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightSpecularColorWithPower( l ), entry.ElementCount ); } } break; case AutoConstantType.LightPositionArray: { // Get as 4D vector, works for directional lights too for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightAs4DVector( l ), entry.ElementCount ); } } break; case AutoConstantType.LightDirectionArray: for ( var l = 0; l < entry.Data; ++l ) { vec3 = source.GetLightDirection( l ); // Set as 4D vector for compatibility WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, new Vector4( vec3.x, vec3.y, vec3.z, 0.0f ), entry.ElementCount ); } break; case AutoConstantType.LightPositionViewSpaceArray: for ( var l = 0; l < entry.Data; ++l ) { vec4 = source.GetLightAs4DVector( l ); WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.ViewMatrix.TransformAffine( vec4 ), entry.ElementCount ); } break; case AutoConstantType.LightDirectionViewSpaceArray: { source.InverseTransposeViewMatrix.Extract3x3Matrix( out m3 ); for ( var l = 0; l < entry.Data; ++l ) { vec3 = m3*source.GetLightDirection( l ); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, new Vector4( vec3.x, vec3.y, vec3.z, 0.0f ), entry.ElementCount ); } } break; case AutoConstantType.LightPowerScaleArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightPowerScale( l ) ); } break; case AutoConstantType.LightAttenuationArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightAttenuation( l ), entry.ElementCount ); } break; case AutoConstantType.SpotLightParamsArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetSpotlightParams( l ), entry.ElementCount ); } break; case AutoConstantType.DerivedLightDiffuseColor: { WriteRawConstant( entry.PhysicalIndex, source.GetLightDiffuseColorWithPower( entry.Data )*source.SurfaceDiffuse, entry.ElementCount ); } break; case AutoConstantType.DerivedLightSpecularColor: WriteRawConstant( entry.PhysicalIndex, source.GetLightSpecularColorWithPower( entry.Data )*source.SurfaceSpecular, entry.ElementCount ); break; case AutoConstantType.DerivedLightDiffuseColorArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightDiffuseColorWithPower( l )*source.SurfaceDiffuse, entry.ElementCount ); } break; case AutoConstantType.DerivedLightSpecularColorArray: for ( var l = 0; l < entry.Data; ++l ) { WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetLightSpecularColorWithPower( l )*source.SurfaceSpecular, entry.ElementCount ); } break; case AutoConstantType.TextureViewProjMatrix: // can also be updated in lights WriteRawConstant( entry.PhysicalIndex, source.GetTextureViewProjectionMatrix( entry.Data ), entry.ElementCount ); break; case AutoConstantType.TextureViewProjMatrixArray: for ( var l = 0; l < entry.Data; ++l ) { // can also be updated in lights WriteRawConstant( entry.PhysicalIndex + l*entry.ElementCount, source.GetTextureViewProjectionMatrix( l ), entry.ElementCount ); } break; case AutoConstantType.SpotLightViewProjMatrix: WriteRawConstant( entry.PhysicalIndex, source.GetSpotlightViewProjMatrix( entry.Data ), entry.ElementCount ); break; default: break; } } }
public void UpdateAutoParams( AutoParamDataSource source, GpuProgramParameters.GpuParamVariability mask ) { if (HasVertexProgram) { // Update vertex program auto params _vertexProgramUsage.Params.UpdateAutoParams( source, mask ); } if (HasGeometryProgram) { // Update geometry program auto params _geometryProgramUsage.Params.UpdateAutoParams(source, mask); } if (HasFragmentProgram) { // Update fragment program auto params _fragmentProgramUsage.Params.UpdateAutoParams(source, mask); } }
/// <summary> /// Update any automatic parameters (except lights) on this pass. /// </summary> public void UpdateAutoParamsNoLights( AutoParamDataSource source ) { // auto update vertex program parameters if ( this.HasVertexProgram ) { _vertexProgramUsage.Params.UpdateAutoParamsNoLights( source ); } // auto update fragment program parameters if ( this.HasFragmentProgram ) { _fragmentProgramUsage.Params.UpdateAutoParamsNoLights( source ); } }
public void UpdateAutoParams(AutoParamDataSource source, GpuParamVariability mask) { // abort early if no autos if (!HasAutoConstantType) { return; } if ((mask & this._combinedVariability) == 0) { return; } this.activePassIterationIndex = int.MaxValue; Matrix3 m3; Vector4 vec4; Vector3 vec3; // loop through and update all constants based on their type foreach (var entry in this.autoConstants) { // Only update needed slots if ((entry.Variability & mask) == 0) { continue; } switch (entry.Type) { case AutoConstantType.ViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.ViewMatrix, entry.ElementCount); break; case AutoConstantType.InverseViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseViewMatrix, entry.ElementCount); break; case AutoConstantType.TransposeViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeViewMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeViewMatrix, entry.ElementCount); break; case AutoConstantType.ProjectionMatrix: WriteRawConstant(entry.PhysicalIndex, source.ProjectionMatrix, entry.ElementCount); break; case AutoConstantType.InverseProjectionMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseProjectionMatrix, entry.ElementCount); break; case AutoConstantType.TransposeProjectionMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeProjectionMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeProjectionMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeProjectionMatrix, entry.ElementCount); break; case AutoConstantType.ViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.ViewProjectionMatrix, entry.ElementCount); break; case AutoConstantType.InverseViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseViewProjMatrix, entry.ElementCount); break; case AutoConstantType.TransposeViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeViewProjMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeViewProjMatrix, entry.ElementCount); break; case AutoConstantType.RenderTargetFlipping: WriteRawConstant(entry.PhysicalIndex, source.CurrentRenderTarget.RequiresTextureFlipping ? -1.0f : 1.0f); break; case AutoConstantType.VertexWinding: { var rsys = Root.Instance.RenderSystem; WriteRawConstant(entry.PhysicalIndex, rsys.InvertVertexWinding ? -1.0f : 1.0f); break; } // NB ambient light still here because it's not related to a specific light case AutoConstantType.AmbientLightColor: WriteRawConstant(entry.PhysicalIndex, source.AmbientLight, entry.ElementCount); break; case AutoConstantType.DerivedAmbientLightColor: WriteRawConstant(entry.PhysicalIndex, source.DerivedAmbient, entry.ElementCount); break; case AutoConstantType.DerivedSceneColor: WriteRawConstant(entry.PhysicalIndex, source.DerivedSceneColor, entry.ElementCount); break; case AutoConstantType.FogColor: WriteRawConstant(entry.PhysicalIndex, source.FogColor); break; case AutoConstantType.FogParams: WriteRawConstant(entry.PhysicalIndex, source.FogParams, entry.ElementCount); break; case AutoConstantType.SurfaceAmbientColor: WriteRawConstant(entry.PhysicalIndex, source.SurfaceAmbient, entry.ElementCount); break; case AutoConstantType.SurfaceDiffuseColor: WriteRawConstant(entry.PhysicalIndex, source.SurfaceDiffuse, entry.ElementCount); break; case AutoConstantType.SurfaceSpecularColor: WriteRawConstant(entry.PhysicalIndex, source.SurfaceSpecular, entry.ElementCount); break; case AutoConstantType.SurfaceEmissiveColor: WriteRawConstant(entry.PhysicalIndex, source.SurfaceEmissive, entry.ElementCount); break; case AutoConstantType.SurfaceShininess: WriteRawConstant(entry.PhysicalIndex, source.SurfaceShininess); break; case AutoConstantType.CameraPosition: WriteRawConstant(entry.PhysicalIndex, source.CameraPosition, entry.ElementCount); break; case AutoConstantType.Time: WriteRawConstant(entry.PhysicalIndex, source.Time * entry.FData); break; case AutoConstantType.Time_0_X: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_X(entry.FData)); break; case AutoConstantType.CosTime_0_X: WriteRawConstant(entry.PhysicalIndex, source.GetCosTime_0_X(entry.FData)); break; case AutoConstantType.SinTime_0_X: WriteRawConstant(entry.PhysicalIndex, source.GetSinTime_0_X(entry.FData)); break; case AutoConstantType.TanTime_0_X: WriteRawConstant(entry.PhysicalIndex, source.GetTanTime_0_X(entry.FData)); break; case AutoConstantType.Time_0_X_Packed: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_X_Packed(entry.FData), entry.ElementCount); break; case AutoConstantType.Time_0_1: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_1(entry.FData)); break; case AutoConstantType.CosTime_0_1: WriteRawConstant(entry.PhysicalIndex, source.GetCosTime_0_1(entry.FData)); break; case AutoConstantType.SinTime_0_1: WriteRawConstant(entry.PhysicalIndex, source.GetSinTime_0_1(entry.FData)); break; case AutoConstantType.TanTime_0_1: WriteRawConstant(entry.PhysicalIndex, source.GetTanTime_0_1(entry.FData)); break; case AutoConstantType.Time_0_1_Packed: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_1_Packed(entry.FData), entry.ElementCount); break; case AutoConstantType.Time_0_2PI: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_2Pi(entry.FData)); break; case AutoConstantType.CosTime_0_2PI: WriteRawConstant(entry.PhysicalIndex, source.GetCosTime_0_2Pi(entry.FData)); break; case AutoConstantType.SinTime_0_2PI: WriteRawConstant(entry.PhysicalIndex, source.GetSinTime_0_2Pi(entry.FData)); break; case AutoConstantType.TanTime_0_2PI: WriteRawConstant(entry.PhysicalIndex, source.GetTanTime_0_2Pi(entry.FData)); break; case AutoConstantType.Time_0_2PI_Packed: WriteRawConstant(entry.PhysicalIndex, source.GetTime_0_2Pi_Packed(entry.FData), entry.ElementCount); break; case AutoConstantType.FrameTime: WriteRawConstant(entry.PhysicalIndex, source.FrameTime * entry.FData); break; case AutoConstantType.FPS: WriteRawConstant(entry.PhysicalIndex, source.FPS); break; case AutoConstantType.ViewportWidth: WriteRawConstant(entry.PhysicalIndex, source.ViewportWidth); break; case AutoConstantType.ViewportHeight: WriteRawConstant(entry.PhysicalIndex, source.ViewportHeight); break; case AutoConstantType.InverseViewportWidth: WriteRawConstant(entry.PhysicalIndex, source.InverseViewportWidth); break; case AutoConstantType.InverseViewportHeight: WriteRawConstant(entry.PhysicalIndex, source.InverseViewportHeight); break; case AutoConstantType.ViewportSize: { WriteRawConstant(entry.PhysicalIndex, new Vector4(source.ViewportWidth, source.ViewportHeight, source.InverseViewportWidth, source.InverseViewportHeight), entry.ElementCount); } break; case AutoConstantType.TexelOffsets: { var rsys = Root.Instance.RenderSystem; WriteRawConstant(entry.PhysicalIndex, new Vector4(rsys.HorizontalTexelOffset, rsys.VerticalTexelOffset, rsys.HorizontalTexelOffset * source.InverseViewportWidth, rsys.VerticalTexelOffset * source.InverseViewportHeight), entry.ElementCount); } break; case AutoConstantType.TextureSize: WriteRawConstant(entry.PhysicalIndex, source.GetTextureSize(entry.Data), entry.ElementCount); break; case AutoConstantType.InverseTextureSize: WriteRawConstant(entry.PhysicalIndex, source.GetInverseTextureSize(entry.Data), entry.ElementCount); break; case AutoConstantType.PackedTextureSize: WriteRawConstant(entry.PhysicalIndex, source.GetPackedTextureSize(entry.Data), entry.ElementCount); break; case AutoConstantType.SceneDepthRange: WriteRawConstant(entry.PhysicalIndex, source.SceneDepthRange, entry.ElementCount); break; case AutoConstantType.ViewDirection: WriteRawConstant(entry.PhysicalIndex, source.ViewDirection); break; case AutoConstantType.ViewSideVector: WriteRawConstant(entry.PhysicalIndex, source.ViewSideVector); break; case AutoConstantType.ViewUpVector: WriteRawConstant(entry.PhysicalIndex, source.ViewUpVector); break; case AutoConstantType.FOV: WriteRawConstant(entry.PhysicalIndex, source.FOV); break; case AutoConstantType.NearClipDistance: WriteRawConstant(entry.PhysicalIndex, source.NearClipDistance); break; case AutoConstantType.FarClipDistance: WriteRawConstant(entry.PhysicalIndex, source.FarClipDistance); break; case AutoConstantType.PassNumber: WriteRawConstant(entry.PhysicalIndex, (float)source.PassNumber); break; case AutoConstantType.PassIterationNumber: { // this is actually just an initial set-up, it's bound separately, so still global WriteRawConstant(entry.PhysicalIndex, 0.0f); this.activePassIterationIndex = entry.PhysicalIndex; } break; case AutoConstantType.TextureMatrix: WriteRawConstant(entry.PhysicalIndex, source.GetTextureTransformMatrix(entry.Data), entry.ElementCount); break; case AutoConstantType.LODCameraPosition: WriteRawConstant(entry.PhysicalIndex, source.LodCameraPosition, entry.ElementCount); break; case AutoConstantType.TextureWorldViewProjMatrix: // can also be updated in lights WriteRawConstant(entry.PhysicalIndex, source.GetTextureWorldViewProjMatrix(entry.Data), entry.ElementCount); break; case AutoConstantType.TextureWorldViewProjMatrixArray: for (var l = 0; l < entry.Data; ++l) { // can also be updated in lights WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetTextureWorldViewProjMatrix(l), entry.ElementCount); } break; case AutoConstantType.SpotLightWorldViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.GetSpotlightWorldViewProjMatrix(entry.Data), entry.ElementCount); break; case AutoConstantType.LightPositionObjectSpace: { vec4 = source.GetLightAs4DVector(entry.Data); vec3 = new Vector3(vec4.x, vec4.y, vec4.z); if (vec4.w > 0.0f) { // point light vec3 = source.InverseWorldMatrix.TransformAffine(vec3); } else { // directional light // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix(out m3); vec3 = (m3 * vec3).ToNormalized(); } WriteRawConstant(entry.PhysicalIndex, new Vector4(vec3.x, vec3.y, vec3.z, vec4.w), entry.ElementCount); } break; case AutoConstantType.LightDirectionObjectSpace: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix(out m3); vec3 = m3 * source.GetLightDirection(entry.Data); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant(entry.PhysicalIndex, new Vector4(vec3.x, vec3.y, vec3.z, 0.0f), entry.ElementCount); } break; case AutoConstantType.LightDistanceObjectSpace: { vec3 = source.InverseWorldMatrix.TransformAffine(source.GetLightPosition(entry.Data)); WriteRawConstant(entry.PhysicalIndex, vec3.Length); } break; case AutoConstantType.LightPositionObjectSpaceArray: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix(out m3); for (var l = 0; l < entry.Data; ++l) { vec4 = source.GetLightAs4DVector(l); vec3 = new Vector3(vec4.x, vec4.y, vec4.z); if (vec4.w > 0.0f) { // point light vec3 = source.InverseWorldMatrix.TransformAffine(vec3); } else { // directional light vec3 = (m3 * vec3).ToNormalized(); } WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, new Vector4(vec3.x, vec3.y, vec3.z, vec4.w), entry.ElementCount); } } break; case AutoConstantType.LightDirectionObjectSpaceArray: { // We need the inverse of the inverse transpose source.InverseTransposeWorldMatrix.Inverse().Extract3x3Matrix(out m3); for (var l = 0; l < entry.Data; ++l) { vec3 = m3 * source.GetLightDirection(l); vec3.Normalize(); WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, new Vector4(vec3.x, vec3.y, vec3.z, 0.0f), entry.ElementCount); } } break; case AutoConstantType.LightDistanceObjectSpaceArray: for (var l = 0; l < entry.Data; ++l) { vec3 = source.InverseWorldMatrix.TransformAffine(source.GetLightPosition(l)); WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, vec3.Length); } break; case AutoConstantType.WorldMatrix: WriteRawConstant(entry.PhysicalIndex, source.WorldMatrix, entry.ElementCount); break; case AutoConstantType.InverseWorldMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseWorldMatrix, entry.ElementCount); break; case AutoConstantType.TransposeWorldMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeWorldMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeWorldMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeWorldMatrix, entry.ElementCount); break; case AutoConstantType.WorldMatrixArray3x4: { // Loop over matrices var pMatrix = source.WorldMatrixArray; var numMatrices = source.WorldMatrixCount; var index = entry.PhysicalIndex; var floatArray = new float[16]; for (var m = 0; m < numMatrices; ++m) { pMatrix[m].MakeFloatArray(floatArray); _writeRawConstants(index, floatArray, 12); index += 12; } } break; case AutoConstantType.WorldMatrixArray: WriteRawConstant(entry.PhysicalIndex, source.WorldMatrixArray, source.WorldMatrixCount); break; case AutoConstantType.WorldViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.WorldViewMatrix, entry.ElementCount); break; case AutoConstantType.InverseWorldViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseWorldViewMatrix, entry.ElementCount); break; case AutoConstantType.TransposeWorldViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeWorldViewMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeWorldViewMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeWorldViewMatrix, entry.ElementCount); break; case AutoConstantType.WorldViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.WorldViewProjMatrix, entry.ElementCount); break; case AutoConstantType.InverseWorldViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseWorldViewProjMatrix, entry.ElementCount); break; case AutoConstantType.TransposeWorldViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.TransposeWorldViewProjMatrix, entry.ElementCount); break; case AutoConstantType.InverseTransposeWorldViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.InverseTransposeWorldViewProjMatrix, entry.ElementCount); break; case AutoConstantType.CameraPositionObjectSpace: WriteRawConstant(entry.PhysicalIndex, source.CameraPositionObjectSpace, entry.ElementCount); break; case AutoConstantType.LODCameraPositionObjectSpace: WriteRawConstant(entry.PhysicalIndex, source.LodCameraPositionObjectSpace, entry.ElementCount); break; case AutoConstantType.Custom: case AutoConstantType.AnimationParametric: source.CurrentRenderable.UpdateCustomGpuParameter(entry, this); break; case AutoConstantType.LightCustom: source.UpdateLightCustomGpuParameter(entry, this); break; case AutoConstantType.LightCount: WriteRawConstant(entry.PhysicalIndex, source.LightCount); break; case AutoConstantType.LightDiffuseColor: WriteRawConstant(entry.PhysicalIndex, source.GetLightDiffuse(entry.Data), entry.ElementCount); break; case AutoConstantType.LightSpecularColor: WriteRawConstant(entry.PhysicalIndex, source.GetLightSpecular(entry.Data), entry.ElementCount); break; case AutoConstantType.LightPosition: { // Get as 4D vector, works for directional lights too // Use element count in case uniform slot is smaller WriteRawConstant(entry.PhysicalIndex, source.GetLightAs4DVector(entry.Data), entry.ElementCount); } break; case AutoConstantType.LightDirection: { vec3 = source.GetLightDirection(entry.Data); // Set as 4D vector for compatibility // Use element count in case uniform slot is smaller WriteRawConstant(entry.PhysicalIndex, new Vector4(vec3.x, vec3.y, vec3.z, 1.0f), entry.ElementCount); } break; case AutoConstantType.LightPositionViewSpace: { vec4 = source.GetLightAs4DVector(entry.Data); WriteRawConstant(entry.PhysicalIndex, source.ViewMatrix.TransformAffine(vec4), entry.ElementCount); } break; case AutoConstantType.LightDirectionViewSpace: { source.InverseTransposeViewMatrix.Extract3x3Matrix(out m3); // inverse transpose in case of scaling vec3 = m3 * source.GetLightDirection(entry.Data); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant(entry.PhysicalIndex, new Vector4(vec3.x, vec3.y, vec3.z, 0.0f), entry.ElementCount); } break; case AutoConstantType.ShadowExtrusionDistance: { // extrusion is in object-space, so we have to rescale by the inverse // of the world scaling to deal with scaled objects source.WorldMatrix.Extract3x3Matrix(out m3); WriteRawConstant(entry.PhysicalIndex, source.ShadowExtrusionDistance / Sqrt( Max(Max(m3.GetColumn(0).LengthSquared, m3.GetColumn(1).LengthSquared), m3.GetColumn(2).LengthSquared))); } break; case AutoConstantType.ShadowSceneDepthRange: WriteRawConstant(entry.PhysicalIndex, source.GetShadowSceneDepthRange(entry.Data)); break; case AutoConstantType.ShadowColor: WriteRawConstant(entry.PhysicalIndex, source.ShadowColor, entry.ElementCount); break; case AutoConstantType.LightPowerScale: WriteRawConstant(entry.PhysicalIndex, source.GetLightPowerScale(entry.Data)); break; case AutoConstantType.LightDiffuseColorPowerScaled: WriteRawConstant(entry.PhysicalIndex, source.GetLightDiffuseColorWithPower(entry.Data), entry.ElementCount); break; case AutoConstantType.LightSpecularColorPowerScaled: WriteRawConstant(entry.PhysicalIndex, source.GetLightSpecularColorWithPower(entry.Data), entry.ElementCount); break; case AutoConstantType.LightNumber: WriteRawConstant(entry.PhysicalIndex, source.GetLightNumber(entry.Data)); break; case AutoConstantType.LightCastsShadows: WriteRawConstant(entry.PhysicalIndex, source.GetLightCastsShadows(entry.Data)); break; case AutoConstantType.LightAttenuation: WriteRawConstant(entry.PhysicalIndex, source.GetLightAttenuation(entry.Data), entry.ElementCount); break; case AutoConstantType.SpotLightParams: WriteRawConstant(entry.PhysicalIndex, source.GetSpotlightParams(entry.Data), entry.ElementCount); break; case AutoConstantType.LightDiffuseColorArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightDiffuse(l), entry.ElementCount); } break; case AutoConstantType.LightSpecularColorArray: { for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightSpecular(l), entry.ElementCount); } } break; case AutoConstantType.LightDiffuseColorPowerScaledArray: { for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightDiffuseColorWithPower(l), entry.ElementCount); } } break; case AutoConstantType.LightSpecularColorPowerScaledArray: { for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightSpecularColorWithPower(l), entry.ElementCount); } } break; case AutoConstantType.LightPositionArray: { // Get as 4D vector, works for directional lights too for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightAs4DVector(l), entry.ElementCount); } } break; case AutoConstantType.LightDirectionArray: for (var l = 0; l < entry.Data; ++l) { vec3 = source.GetLightDirection(l); // Set as 4D vector for compatibility WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, new Vector4(vec3.x, vec3.y, vec3.z, 0.0f), entry.ElementCount); } break; case AutoConstantType.LightPositionViewSpaceArray: for (var l = 0; l < entry.Data; ++l) { vec4 = source.GetLightAs4DVector(l); WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.ViewMatrix.TransformAffine(vec4), entry.ElementCount); } break; case AutoConstantType.LightDirectionViewSpaceArray: { source.InverseTransposeViewMatrix.Extract3x3Matrix(out m3); for (var l = 0; l < entry.Data; ++l) { vec3 = m3 * source.GetLightDirection(l); vec3.Normalize(); // Set as 4D vector for compatibility WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, new Vector4(vec3.x, vec3.y, vec3.z, 0.0f), entry.ElementCount); } } break; case AutoConstantType.LightPowerScaleArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightPowerScale(l)); } break; case AutoConstantType.LightAttenuationArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightAttenuation(l), entry.ElementCount); } break; case AutoConstantType.SpotLightParamsArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetSpotlightParams(l), entry.ElementCount); } break; case AutoConstantType.DerivedLightDiffuseColor: { WriteRawConstant(entry.PhysicalIndex, source.GetLightDiffuseColorWithPower(entry.Data) * source.SurfaceDiffuse, entry.ElementCount); } break; case AutoConstantType.DerivedLightSpecularColor: WriteRawConstant(entry.PhysicalIndex, source.GetLightSpecularColorWithPower(entry.Data) * source.SurfaceSpecular, entry.ElementCount); break; case AutoConstantType.DerivedLightDiffuseColorArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightDiffuseColorWithPower(l) * source.SurfaceDiffuse, entry.ElementCount); } break; case AutoConstantType.DerivedLightSpecularColorArray: for (var l = 0; l < entry.Data; ++l) { WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetLightSpecularColorWithPower(l) * source.SurfaceSpecular, entry.ElementCount); } break; case AutoConstantType.TextureViewProjMatrix: // can also be updated in lights WriteRawConstant(entry.PhysicalIndex, source.GetTextureViewProjectionMatrix(entry.Data), entry.ElementCount); break; case AutoConstantType.TextureViewProjMatrixArray: for (var l = 0; l < entry.Data; ++l) { // can also be updated in lights WriteRawConstant(entry.PhysicalIndex + l * entry.ElementCount, source.GetTextureViewProjectionMatrix(l), entry.ElementCount); } break; case AutoConstantType.SpotLightViewProjMatrix: WriteRawConstant(entry.PhysicalIndex, source.GetSpotlightViewProjMatrix(entry.Data), entry.ElementCount); break; default: break; } } }
/// <summary> /// Updates the automatic light parameters 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 UpdateAutoParamsLightsOnly( AutoParamDataSource source ) { // return if no constants if ( !this.HasAutoConstantType ) { return; } PassIterationNumberIndex = int.MaxValue; // loop through and update all constants based on their type for ( int i = 0; i < autoConstantList.Count; i++ ) { AutoConstantEntry entry = autoConstantList[ i ]; Vector3 vec3; switch ( entry.Type ) { case AutoConstantType.LightDiffuseColor: SetConstant( entry.PhysicalIndex, source.GetLight( entry.Data ).Diffuse ); break; case AutoConstantType.LightSpecularColor: SetConstant( entry.PhysicalIndex, source.GetLight( entry.Data ).Specular ); break; case AutoConstantType.LightPosition: // Fix from Multiverse to enable Normal Mapping Sample Material from OGRE SetConstant( entry.PhysicalIndex, source.GetLight( entry.Data ).GetAs4DVector() ); break; case AutoConstantType.LightDirection: vec3 = source.GetLight( 1 ).DerivedDirection; SetConstant( entry.PhysicalIndex, vec3.x, vec3.y, vec3.z, 1.0f ); break; case AutoConstantType.LightPositionObjectSpace: SetConstant( entry.PhysicalIndex, source.InverseWorldMatrix * source.GetLight( entry.Data ).GetAs4DVector() ); break; case AutoConstantType.LightDirectionObjectSpace: vec3 = source.InverseWorldMatrix * source.GetLight( entry.Data ).DerivedDirection; vec3.Normalize(); SetConstant( entry.PhysicalIndex, vec3.x, vec3.y, vec3.z, 1.0f ); break; case AutoConstantType.LightDistanceObjectSpace: vec3 = source.InverseWorldMatrix * source.GetLight( entry.Data ).DerivedPosition; SetConstant( entry.PhysicalIndex, vec3.Length, 0f, 0f, 0f ); break; case AutoConstantType.ShadowExtrusionDistance: SetConstant( entry.PhysicalIndex, source.ShadowExtrusionDistance, 0f, 0f, 0f ); break; case AutoConstantType.LightAttenuation: Light light = source.GetLight( entry.Data ); SetConstant( entry.PhysicalIndex, light.AttenuationRange, light.AttenuationConstant, light.AttenuationLinear, light.AttenuationQuadratic ); break; case AutoConstantType.LightPowerScale: SetConstant( entry.PhysicalIndex, source.GetLightPowerScale( entry.Data ) ); break; case AutoConstantType.WorldMatrix: SetConstant( entry.PhysicalIndex, source.WorldMatrix ); break; //case AutoConstantType.ViewProjMatrix: // SetConstant( entry.PhysicalIndex, source.ViewProjectionMatrix ); // break; case AutoConstantType.PassIterationNumber: SetConstant(entry.PhysicalIndex, 0.0f); PassIterationNumberIndex = entry.PhysicalIndex; break; } } }
/// <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.HasAutoConstantType ) { return; } PassIterationNumberIndex = int.MaxValue; // loop through and update all constants based on their type for ( int i = 0; i < autoConstantList.Count; i++ ) { AutoConstantEntry entry = autoConstantList[ i ]; Matrix4[] matrices = null; int numMatrices = 0; int index = 0; switch ( entry.Type ) { case AutoConstantType.WorldMatrix: SetConstant( entry.PhysicalIndex, source.WorldMatrix ); break; case AutoConstantType.WorldMatrixArray: SetConstant( entry.PhysicalIndex, source.WorldMatrixArray, source.WorldMatrixCount ); break; case AutoConstantType.WorldMatrixArray3x4: matrices = source.WorldMatrixArray; numMatrices = source.WorldMatrixCount; index = entry.PhysicalIndex; 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 AutoConstantType.ViewMatrix: SetConstant( entry.PhysicalIndex, source.ViewMatrix ); break; case AutoConstantType.ProjectionMatrix: SetConstant( entry.PhysicalIndex, source.ProjectionMatrix ); break; case AutoConstantType.ViewProjMatrix: SetConstant( entry.PhysicalIndex, source.ViewProjectionMatrix ); break; case AutoConstantType.WorldViewMatrix: SetConstant( entry.PhysicalIndex, source.WorldViewMatrix ); break; case AutoConstantType.WorldViewProjMatrix: SetConstant( entry.PhysicalIndex, source.WorldViewProjMatrix ); break; case AutoConstantType.InverseWorldMatrix: SetConstant( entry.PhysicalIndex, source.InverseWorldMatrix ); break; case AutoConstantType.InverseViewMatrix: SetConstant( entry.PhysicalIndex, source.InverseViewMatrix ); break; case AutoConstantType.InverseTransposeViewMatrix: SetConstant( entry.PhysicalIndex, source.InverseTransposeViewMatrix ); break; case AutoConstantType.InverseWorldViewMatrix: SetConstant( entry.PhysicalIndex, source.InverseWorldViewMatrix ); break; case AutoConstantType.InverseTransposeWorldViewMatrix: SetConstant( entry.PhysicalIndex, source.InverseTransposeWorldViewMatrix ); break; case AutoConstantType.AmbientLightColor: SetConstant( entry.PhysicalIndex, source.AmbientLight ); break; case AutoConstantType.CameraPositionObjectSpace: SetConstant( entry.PhysicalIndex, source.CameraPositionObjectSpace ); break; case AutoConstantType.CameraPosition: SetConstant( entry.PhysicalIndex, source.CameraPosition ); break; case AutoConstantType.TextureViewProjMatrix: SetConstant( entry.PhysicalIndex, source.TextureViewProjectionMatrix ); break; case AutoConstantType.Custom: case AutoConstantType.AnimationParametric: source.Renderable.UpdateCustomGpuParameter( entry, this ); break; case AutoConstantType.FogParams: SetConstant( entry.PhysicalIndex, source.FogParams ); break; case AutoConstantType.ViewDirection: SetConstant( entry.PhysicalIndex, source.ViewDirection ); break; case AutoConstantType.ViewSideVector: SetConstant( entry.PhysicalIndex, source.ViewSideVector ); break; case AutoConstantType.ViewUpVector: SetConstant( entry.PhysicalIndex, source.ViewUpVector ); break; case AutoConstantType.NearClipDistance: SetConstant( entry.PhysicalIndex, source.NearClipDistance, 0f, 0f, 0f ); break; case AutoConstantType.FarClipDistance: SetConstant( entry.PhysicalIndex, source.FarClipDistance, 0f, 0f, 0f ); break; case AutoConstantType.MVShadowTechnique: SetConstant( entry.PhysicalIndex, source.MVShadowTechnique ); break; case AutoConstantType.Time: SetConstant( entry.PhysicalIndex, source.Time * entry.FData, 0f, 0f, 0f ); break; case AutoConstantType.Time_0_X: SetConstant( entry.PhysicalIndex, source.Time % entry.FData, 0f, 0f, 0f ); break; case AutoConstantType.SinTime_0_X: SetConstant( entry.PhysicalIndex, Utility.Sin( source.Time % entry.FData ), 0f, 0f, 0f ); break; case AutoConstantType.Time_0_1: SetConstant( entry.PhysicalIndex, (float)( source.Time % 1 ), 0f, 0f, 0f ); break; case AutoConstantType.RenderTargetFlipping: SetIntConstant( entry.PhysicalIndex, source.RenderTarget.RequiresTextureFlipping ? -1 : 1 ); break; case AutoConstantType.PassNumber: SetIntConstant( entry.PhysicalIndex, source.PassNumber ); break; case AutoConstantType.PassIterationNumber: SetConstant(entry.PhysicalIndex, 0.0f); PassIterationNumberIndex = entry.PhysicalIndex; break; } } }
/// <summary> /// Update automatic parameters. /// </summary> /// <param name="source">The source of the parameters</param> /// <param name="mask">A mask of GpuParamVariability which identifies which autos will need updating</param> public void UpdateAutoParams( AutoParamDataSource source, GpuParamVariability mask ) { // abort early if no autos if (!HasAutoConstantType) return; // Axiom TODO: implement this early out opt // abort early if variability doesn't match any param //if (!(mask & _combinedVariability)) // return; PassIterationNumberIndex = int.MaxValue; // loop through and update all constants based on their type foreach ( var entry in autoConstantList ) { // Only update needed slots if ((entry.Variability & mask) == 0) continue; Matrix4[] matrices; int numMatrices; int index; switch (entry.Type) { case AutoConstantType.ViewMatrix: SetConstant(entry.PhysicalIndex, source.ViewMatrix); break; case AutoConstantType.InverseViewMatrix: SetConstant(entry.PhysicalIndex, source.InverseViewMatrix); break; case AutoConstantType.InverseTransposeViewMatrix: SetConstant(entry.PhysicalIndex, source.InverseTransposeViewMatrix); break; case AutoConstantType.ProjectionMatrix: SetConstant(entry.PhysicalIndex, source.ProjectionMatrix); break; case AutoConstantType.ViewProjMatrix: SetConstant(entry.PhysicalIndex, source.ViewProjectionMatrix); break; case AutoConstantType.RenderTargetFlipping: SetIntConstant(entry.PhysicalIndex, source.RenderTarget.RequiresTextureFlipping ? -1 : 1); break; case AutoConstantType.VertexWinding: { var rsys = Root.Instance.RenderSystem; SetIntConstant(entry.PhysicalIndex, rsys.InvertVertexWinding ? -1 : 1); break; } case AutoConstantType.AmbientLightColor: SetConstant( entry.PhysicalIndex, source.AmbientLight ); break; case AutoConstantType.WorldMatrix: SetConstant(entry.PhysicalIndex, source.WorldMatrix); break; case AutoConstantType.WorldMatrixArray: SetConstant(entry.PhysicalIndex, source.WorldMatrixArray, source.WorldMatrixCount); break; case AutoConstantType.WorldMatrixArray3x4: matrices = source.WorldMatrixArray; numMatrices = source.WorldMatrixCount; index = entry.PhysicalIndex; 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 AutoConstantType.WorldViewMatrix: SetConstant(entry.PhysicalIndex, source.WorldViewMatrix); break; case AutoConstantType.WorldViewProjMatrix: SetConstant(entry.PhysicalIndex, source.WorldViewProjMatrix); break; case AutoConstantType.InverseWorldMatrix: SetConstant(entry.PhysicalIndex, source.InverseWorldMatrix); break; case AutoConstantType.InverseWorldViewMatrix: SetConstant(entry.PhysicalIndex, source.InverseWorldViewMatrix); break; case AutoConstantType.InverseTransposeWorldViewMatrix: SetConstant(entry.PhysicalIndex, source.InverseTransposeWorldViewMatrix); break; case AutoConstantType.CameraPositionObjectSpace: SetConstant(entry.PhysicalIndex, source.CameraPositionObjectSpace); break; case AutoConstantType.CameraPosition: SetConstant(entry.PhysicalIndex, source.CameraPosition); break; case AutoConstantType.TextureViewProjMatrix: SetConstant(entry.PhysicalIndex, source.TextureViewProjectionMatrix); break; case AutoConstantType.Custom: case AutoConstantType.AnimationParametric: source.Renderable.UpdateCustomGpuParameter(entry, this); break; case AutoConstantType.FogParams: SetConstant(entry.PhysicalIndex, source.FogParams); break; case AutoConstantType.ViewDirection: SetConstant(entry.PhysicalIndex, source.ViewDirection); break; case AutoConstantType.ViewSideVector: SetConstant(entry.PhysicalIndex, source.ViewSideVector); break; case AutoConstantType.ViewUpVector: SetConstant(entry.PhysicalIndex, source.ViewUpVector); break; case AutoConstantType.NearClipDistance: SetConstant(entry.PhysicalIndex, source.NearClipDistance, 0f, 0f, 0f); break; case AutoConstantType.FarClipDistance: SetConstant(entry.PhysicalIndex, source.FarClipDistance, 0f, 0f, 0f); break; case AutoConstantType.MVShadowTechnique: SetConstant(entry.PhysicalIndex, source.MVShadowTechnique); break; case AutoConstantType.Time: SetConstant(entry.PhysicalIndex, source.Time * entry.FData, 0f, 0f, 0f); break; case AutoConstantType.Time_0_X: SetConstant(entry.PhysicalIndex, source.Time % entry.FData, 0f, 0f, 0f); break; case AutoConstantType.SinTime_0_X: SetConstant(entry.PhysicalIndex, Utility.Sin(source.Time % entry.FData), 0f, 0f, 0f); break; case AutoConstantType.Time_0_1: SetConstant(entry.PhysicalIndex, (float)(source.Time % 1), 0f, 0f, 0f); break; case AutoConstantType.PassNumber: SetIntConstant(entry.PhysicalIndex, source.PassNumber); break; case AutoConstantType.PassIterationNumber: SetConstant(entry.PhysicalIndex, 0.0f); PassIterationNumberIndex = entry.PhysicalIndex; break; default: throw new NotImplementedException(); } } }
protected override void dispose( bool disposeManagedResources ) { if ( !IsDisposed ) { if ( disposeManagedResources ) { if ( SceneManagerDestroyed != null ) { SceneManagerDestroyed( this ); } ClearScene(); RemoveAllCameras(); if ( op != null ) { if ( !op.IsDisposed ) { op.Dispose(); } op = null; } if ( this.autoParamDataSource != null ) { if ( !this.autoParamDataSource.IsDisposed ) { this.autoParamDataSource.Dispose(); } this.autoParamDataSource = null; } if ( this.rootSceneNode != null ) { if ( !this.rootSceneNode.IsDisposed ) { this.rootSceneNode.Dispose(); } this.rootSceneNode = null; } } } base.dispose( disposeManagedResources ); }
public override void UpdateGpuProgramsParams( IRenderable rend, Pass pass, AutoParamDataSource source, Core.Collections.LightList lightList ) { if ( this.lightParamsList.Count == 0 ) { return; } var curLightType = LightType.Directional; int curSearchLightIndex = 0; Matrix4 matWorld = source.WorldMatrix; Matrix3 matWorldInvRotation; var vRow0 = new Vector3( matWorld[ 0, 0 ], matWorld[ 0, 1 ], matWorld[ 0, 2 ] ); var vRow1 = new Vector3( matWorld[ 1, 0 ], matWorld[ 1, 1 ], matWorld[ 1, 2 ] ); var vRow2 = new Vector3( matWorld[ 2, 0 ], matWorld[ 2, 1 ], matWorld[ 2, 2 ] ); vRow0.Normalize(); vRow1.Normalize(); vRow2.Normalize(); matWorldInvRotation = new Matrix3( vRow0, vRow1, vRow2 ); //update inverse rotation parameter if ( this.worldInvRotMatrix != null ) { this.worldInvRotMatrix.SetGpuParameter( matWorldInvRotation ); } //update per light parameters for ( int i = 0; i < this.lightParamsList.Count; i++ ) { LightParams curParams = this.lightParamsList[ i ]; if ( curLightType != curParams.Type ) { curLightType = curParams.Type; curSearchLightIndex = 0; } Light srcLight = null; Vector4 vParameter; ColorEx color; //Search a matching light from the current sorted lights of the given renderable for ( int j = 0; j < lightList.Count; j++ ) { if ( lightList[ j ].Type == curLightType ) { srcLight = lightList[ j ]; curSearchLightIndex = j + 1; break; } } //No matching light found -> use a blank dummy light for parameter update if ( srcLight == null ) { srcLight = blankLight; } switch ( curParams.Type ) { case LightType.Directional: { Vector3 vec3; //Update light direction (object space) vec3 = matWorldInvRotation*srcLight.DerivedDirection; vec3.Normalize(); vParameter.x = -vec3.x; vParameter.y = -vec3.y; vParameter.z = -vec3.z; vParameter.w = 0.0; curParams.Direction.SetGpuParameter( vParameter ); } break; case LightType.Point: //update light position (world space) vParameter = srcLight.GetAs4DVector( true ); curParams.Position.SetGpuParameter( vParameter ); //Update light attenuation parameters. vParameter.x = srcLight.AttenuationRange; vParameter.y = srcLight.AttenuationConstant; vParameter.z = srcLight.AttenuationLinear; vParameter.w = srcLight.AttenuationQuadratic; curParams.AttenuatParams.SetGpuParameter( vParameter ); break; case LightType.Spotlight: { Vector3 vec3; //Update light position (world space) vParameter = srcLight.GetAs4DVector( true ); curParams.Position.SetGpuParameter( vParameter ); //Update light direction (object space) vec3 = matWorldInvRotation*srcLight.DerivedDirection; vec3.Normalize(); vParameter.x = -vec3.x; vParameter.y = -vec3.y; vParameter.z = -vec3.z; vParameter.w = 0.0; curParams.Direction.SetGpuParameter( vParameter ); //Update light attenuation parameters. vParameter.x = srcLight.AttenuationRange; vParameter.y = srcLight.AttenuationConstant; vParameter.z = srcLight.AttenuationLinear; vParameter.w = srcLight.AttenuationQuadratic; curParams.AttenuatParams.SetGpuParameter( vParameter ); //Update spotlight parameters Real phi = System.Math.Cos( (double)srcLight.SpotlightOuterAngle*0.5f ); Real theta = System.Math.Cos( (double)srcLight.SpotlightInnerAngle*0.5f ); vec3.x = theta; vec3.y = phi; vec3.z = srcLight.SpotlightFalloff; curParams.SpotParams.SetGpuParameter( vec3 ); } break; } //Update diffuse color if ( ( this.trackVertexColorType & TrackVertexColor.Diffuse ) == 0 ) { color = srcLight.Diffuse*pass.Diffuse; curParams.DiffuseColor.SetGpuParameter( color ); } else { color = srcLight.Diffuse; curParams.DiffuseColor.SetGpuParameter( color ); } //Update specular color if need to if ( this.specularEnabled ) { //Update diffuse color if ( ( this.trackVertexColorType & TrackVertexColor.Diffuse ) == 0 ) { color = srcLight.Specular*pass.Specular; curParams.SpecularColor.SetGpuParameter( color ); } else { color = srcLight.Specular; curParams.SpecularColor.SetGpuParameter( color ); } } } }
/// <summary> /// Updates the automatic light parameters 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 UpdateAutoParamsLightsOnly(AutoParamDataSource source) { // return if no constants if(!this.HasAutoConstants) { return; } // loop through and update all constants based on their type for(int constantIndex = 0; constantIndex < autoConstantList.Count; constantIndex++) { AutoConstantEntry entry = (AutoConstantEntry)autoConstantList[constantIndex]; Vector3 vec3; Light light; int i; switch(entry.type) { case AutoConstants.LightDiffuseColor: SetConstant(entry.index, source.GetLight(entry.data).Diffuse); break; case AutoConstants.LightSpecularColor: SetConstant(entry.index, source.GetLight(entry.data).Specular); break; case AutoConstants.LightPosition: SetConstant(entry.index, source.GetLight(entry.data).DerivedPosition); break; case AutoConstants.LightDirection: vec3 = source.GetLight(entry.data).DerivedDirection; SetConstant(entry.index, vec3.x, vec3.y, vec3.z, 1.0f); break; case AutoConstants.LightPositionObjectSpace: SetConstant(entry.index, source.InverseWorldMatrix * source.GetLight(entry.data).GetAs4DVector()); break; case AutoConstants.LightDirectionObjectSpace: vec3 = source.InverseWorldMatrix * source.GetLight(entry.data).DerivedDirection; vec3.Normalize(); SetConstant(entry.index, vec3.x, vec3.y, vec3.z, 1.0f); break; case AutoConstants.LightPositionViewSpace: SetConstant(entry.index, source.ViewMatrix.TransformAffine(source.GetLight(entry.data).GetAs4DVector())); break; case AutoConstants.LightDirectionViewSpace: vec3 = source.InverseViewMatrix.Transpose() * source.GetLight(entry.data).DerivedDirection; vec3.Normalize(); SetConstant(entry.index, vec3.x, vec3.y, vec3.z, 1.0f); break; case AutoConstants.LightDistanceObjectSpace: vec3 = source.InverseWorldMatrix * source.GetLight(entry.data).DerivedPosition; SetConstant(entry.index, vec3.Length); break; case AutoConstants.ShadowExtrusionDistance: SetConstant(entry.index, source.ShadowExtrusionDistance); break; case AutoConstants.ShadowSceneDepthRange: SetConstant(entry.index, source.GetShadowSceneDepthRange(entry.data)); break; case AutoConstants.LightPower: SetConstant(entry.index, source.GetLight(entry.data).PowerScale); break; case AutoConstants.LightAttenuation: light = source.GetLight(entry.data); SetConstant(entry.index, light.AttenuationRange, light.AttenuationConstant, light.AttenuationLinear, light.AttenuationQuadratic); break; case AutoConstants.SpotlightParams: light = source.GetLight(entry.data); if (light.Type == LightType.Spotlight) SetConstant(entry.index, (float)Math.Cos(MathUtil.DegreesToRadians(light.SpotlightInnerAngle) * 0.5), (float)Math.Cos(MathUtil.DegreesToRadians(light.SpotlightOuterAngle) * 0.5), light.SpotlightFalloff, 1.0f); else SetConstant(entry.index, 1f, 0f, 0f, 1f); break; case AutoConstants.LightDiffuseColorArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.GetLight(i).Diffuse); break; case AutoConstants.LightSpecularColorArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.GetLight(i).Specular); break; case AutoConstants.LightPositionArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.GetLight(i).DerivedPosition); break; case AutoConstants.LightDirectionArray: for (i=0; i<entry.data; i++) { vec3 = source.GetLight(i).DerivedDirection; SetConstant(entry.index + i, vec3.x, vec3.y, vec3.z, 1.0f); } break; case AutoConstants.LightPositionObjectSpaceArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.ViewMatrix.TransformAffine(source.GetLight(i).GetAs4DVector())); break; case AutoConstants.LightDirectionObjectSpaceArray: for (i=0; i<entry.data; i++) { vec3 = source.InverseWorldMatrix.TransformAffine(source.GetLight(i).DerivedDirection); SetConstant(entry.index + i, vec3.x, vec3.y, vec3.z, 1.0f); } break; case AutoConstants.LightPositionViewSpaceArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.ViewMatrix.TransformAffine(source.GetLight(i).GetAs4DVector())); break; case AutoConstants.LightDirectionViewSpaceArray: for (i=0; i<entry.data; i++) { vec3 = source.InverseViewMatrix.Transpose() * source.GetLight(i).DerivedDirection; vec3.Normalize(); SetConstant(entry.index + i, vec3.x, vec3.y, vec3.z, 1.0f); } break; case AutoConstants.LightDistanceObjectSpaceArray: for (i=0; i<entry.data; i++) { vec3 = source.InverseWorldMatrix * source.GetLight(i).DerivedPosition; SetConstant(entry.index + i, vec3.Length); } break; case AutoConstants.LightPowerArray: for (i=0; i<entry.data; i++) SetConstant(entry.index + i, source.GetLight(i).PowerScale); break; case AutoConstants.LightAttenuationArray: for (i=0; i<entry.data; i++) { light = source.GetLight(i); SetConstant(entry.index + i, light.AttenuationRange, light.AttenuationConstant, light.AttenuationLinear, light.AttenuationQuadratic); } break; case AutoConstants.SpotlightParamsArray: for (i=0; i<entry.data; i++) { light = source.GetLight(i); if (light.Type == LightType.Spotlight) SetConstant(entry.index + 1, (float)Math.Cos(MathUtil.DegreesToRadians(light.SpotlightInnerAngle) * 0.5), (float)Math.Cos(MathUtil.DegreesToRadians(light.SpotlightOuterAngle) * 0.5), light.SpotlightFalloff, 1.0f); else SetConstant(entry.index + i, 1f, 0f, 0f, 1f); } break; case AutoConstants.DerivedLightDiffuseColor: SetConstant(entry.index, source.GetLight(entry.data).Diffuse * source.CurrentPass.Diffuse); break; case AutoConstants.DerivedLightSpecularColor: SetConstant(entry.index, source.GetLight(entry.data).Diffuse * source.CurrentPass.Specular); break; case AutoConstants.DerivedLightDiffuseColorArray: for (i=0; i<entry.data; i++) { light = source.GetLight(i); SetConstant(entry.index + i, light.Diffuse * source.CurrentPass.Diffuse); } break; case AutoConstants.DerivedLightSpecularColorArray: for (i=0; i<entry.data; i++) { light = source.GetLight(i); SetConstant(entry.index + i, light.Specular * source.CurrentPass.Diffuse); } break; case AutoConstants.TextureViewProjMatrix: SetConstant(entry.index, source.GetTextureViewProjectionMatrix(entry.data)); break; default: // do nothing break; } } }
/// <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; } } }