public void DynamicTexture_Free(Component_Image texture)
{
var item = dynamicTexturesAllocated.Find(i => i.image == texture);
//RenderTargetItem item = null;
//foreach( var i in renderTargetsAllocated )
//{
// if( i.target == renderTarget )
// {
// item = i;
// break;
// }
//}
////can be created for MRT. such render targets can't free.
//if( item == null )
// return;
if (item == null)
{
Log.Fatal("ViewportRenderingContext: DynamicTexture_Free: Dynamic texture is not allocated.");
}
if (dynamicTexturesFree.Contains(item))
{
Log.Fatal("ViewportRenderingContext: DynamicTexture_Free: Dynamic texture is already free.");
}
dynamicTexturesFree.Add(item);
}
//[Browsable( false )]
//public UIControl CreatedControl
//{
// get { return createdControl; }
//}
void CreateRenderTarget()
{
DestroyRenderTarget();
var size = GetDemandedSize();
var hdr = HDR.Value;
var mipmaps = false;
createdImage = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
createdImage.CreateType = Component_Image.TypeEnum._2D;
createdImage.CreateSize = size;
createdImage.CreateMipmaps = mipmaps;
createdImage.CreateFormat = hdr ? PixelFormat.Float32RGBA : PixelFormat.A8R8G8B8;
var usage = Component_Image.Usages.RenderTarget;
if (mipmaps)
{
usage |= Component_Image.Usages.AutoMipmaps;
}
createdImage.CreateUsage = usage;
createdImage.CreateFSAA = 0;
createdImage.Enabled = true;
var renderTexture = createdImage.Result.GetRenderTarget();
createdViewport = renderTexture.AddViewport(true, true);
createdViewport.UpdateBeforeOutput += CreatedViewport_UpdateBeforeOutput;
createdForSize = size;
createdForHDR = hdr;
UpdateAttachedScene();
}
void Init()
{
texture = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
texture.CreateType = Component_Image.TypeEnum._2D;
texture.CreateSize = imageSizeRender; // new Vector2I( imageSizeRender, imageSizeRender );
texture.CreateMipmaps = false;
texture.CreateFormat = imageFormat;
texture.CreateUsage = Component_Image.Usages.RenderTarget;
texture.CreateFSAA = 0;
texture.Enabled = true;
var renderTexture = texture.Result.GetRenderTarget(0, 0);
viewport = renderTexture.AddViewport(false, true);
viewport.AllowRenderScreenLabels = false;
//viewport.UpdateBegin += Viewport_UpdateBegin;
textureRead = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
textureRead.CreateType = Component_Image.TypeEnum._2D;
textureRead.CreateSize = texture.CreateSize;
textureRead.CreateMipmaps = false;
textureRead.CreateFormat = texture.CreateFormat;
textureRead.CreateUsage = Component_Image.Usages.ReadBack | Component_Image.Usages.BlitDestination;
textureRead.CreateFSAA = 0;
textureRead.Enabled = true;
//!!!!
textureRead.Result.PrepareNativeObject();
var imageDataBytes = PixelFormatUtility.GetNumElemBytes(imageFormat) * imageSizeRender.X * imageSizeRender.Y;
imageData = NativeUtility.Alloc(NativeUtility.MemoryAllocationType.Utility, imageDataBytes);
}
/////////////////////////////////////////
//Invoke Method
public virtual void GetFlowGraphRepresentationData(FlowGraphRepresentationData data)
{
if (compiledOneMethod != null)
{
//!!!!может по другому
data.NodeTitle = compiledOneMethod.ToString();
if (cachedFlowGraphNodeImageScriptPrinter == null)
{
cachedFlowGraphNodeImageScriptPrinter = EditorAssemblyInterface.Instance.ScriptPrinterNew();
//cachedFlowGraphNodeImageScriptPrinter = new ScriptPrinter();
//cachedFlowGraphNodeImageScriptPrinter = new ScriptPrinter() { FontSize = 10, BackgroundBrush = System.Windows.Media.Brushes.Gray };
}
//!!!!правильнее знать какое точно разрешение. также скрипт может одновременно быть в нескольких разных нодах разных размеров.
if (cachedFlowGraphNodeImage == null)
{
cachedFlowGraphNodeImage = cachedFlowGraphNodeImageScriptPrinter.PrintToTexture(Code, new Vector2I(512, 256));
}
//if( cachedNodeTexture == null )
// cachedNodeTexture = scriptPrinter.PrintToTexture( Code, new System.Windows.Size( 64, 64 ) );
data.NodeImage = cachedFlowGraphNodeImage;
data.NodeImageView = FlowGraphRepresentationData.NodeImageViewEnum.WideScaled;
data.NodeHeight += 6;
if (FlowSupport)
{
data.NodeContentType = FlowGraphNodeContentType.Flow;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public virtual void ConvertToLDR(ViewportRenderingContext context, ref Component_Image actualTexture)
{
//!!!!может другие тоже форматы? провер¤ть на FloatXX?
var demandFormat = PixelFormat.A8R8G8B8;
if (actualTexture.Result.ResultFormat != demandFormat)
{
var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, demandFormat);
context.SetViewport(newTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ToLDR_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//var size = context.owner.DimensionsInPixels.Size;
//shader.Parameters.Set( "viewportSize", new Vec4( size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y ).ToVec4F() );
//Mat4F identity = Mat4F.Identity;
//shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );
context.RenderQuadToCurrentViewport(shader);
//free old texture
context.DynamicTexture_Free(actualTexture);
actualTexture = newTexture;
}
}
unsafe public override void Render(Component_RenderingPipeline pipeline, ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData)
{
UpdateProcessedCubemaps();
if (mesh != null)
{
var pass = GetMaterialPass();
if (pass != null)
{
////!!!!
//CreatedCubemapUpdate();
//!!!!double
Matrix4F worldMatrix = Matrix4.FromTranslate(context.Owner.CameraSettings.Position).ToMatrix4F();
foreach (var item in mesh.Result.MeshData.RenderOperations)
{
ParameterContainer generalContainer = new ParameterContainer();
generalContainer.Set("multiplier", Multiplier.Value.ToColorValue());
GetRotationMatrix(out var rotation);
generalContainer.Set("rotation", rotation); // Matrix3.FromRotateByZ( Rotation.Value.InRadians() ).ToMatrix3F() );
Component_Image tex = null;
//!!!!сделать GetResultEnvironmentCubemap()?
//!!!!!!где еще его использовать
if (processedEnvironmentCubemap != null)
{
tex = processedEnvironmentCubemap;
}
//else if( AnyCubemapSideIsSpecified() )
// tex = createdCubemap;
else
{
tex = Cubemap;
}
if (tex == null)
{
tex = ResourceUtility.BlackTextureCube;
}
if (tex.Result != null && tex.Result.TextureType == Component_Image.TypeEnum.Cube)
{
var addressingMode = TextureAddressingMode.Clamp;
context.BindTexture(new ViewportRenderingContext.BindTextureData(0 /*"skyboxTexture"*/, tex, addressingMode, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
var containers = new List <ParameterContainer>();
containers.Add(generalContainer);
Bgfx.SetTransform((float *)&worldMatrix);
((Component_RenderingPipeline_Basic)pipeline).RenderOperation(context, item, pass, containers);
}
}
}
}
}
void ProcessCubemaps()
{
processedEnvironmentCubemap = null;
processedIrradianceCubemap = null;
var sourceFileName = Cubemap.Value?.LoadFile.Value?.ResourceName;
if (string.IsNullOrEmpty(sourceFileName))
{
var getByReference = Cubemap.GetByReference;
if (!string.IsNullOrEmpty(getByReference))
{
try
{
if (Path.GetExtension(getByReference) == ".image")
{
sourceFileName = getByReference;
}
}
catch { }
}
}
if (!string.IsNullOrEmpty(sourceFileName))
{
bool skip = false;
if (sourceFileName.Length > 11)
{
var s = sourceFileName.Substring(sourceFileName.Length - 11);
if (s == "_GenEnv.dds" || s == "_GenIrr.dds")
{
skip = true;
}
}
if (!skip)
{
if (!CubemapProcessing.GetOrGenerate(sourceFileName, false, 0, out var envVirtualFileName, out var irrVirtualFileName, out var error))
{
Log.Error(error);
return;
}
if (VirtualFile.Exists(envVirtualFileName))
{
processedEnvironmentCubemap = ResourceManager.LoadResource <Component_Image>(envVirtualFileName);
}
if (VirtualFile.Exists(irrVirtualFileName))
{
processedIrradianceCubemap = ResourceManager.LoadResource <Component_Image>(irrVirtualFileName);
}
}
}
}
void DestroyRenderTarget()
{
if (createdImage != null)
{
createdViewport.UpdateBeforeOutput -= CreatedViewport_UpdateBeforeOutput;
createdImage.Dispose();
createdImage = null;
createdViewport = null;
}
}
/////////////////////////////////////////
protected override void OnRenderUI(CanvasRenderer renderer)
{
base.OnRenderUI(renderer);
//bool backColorZero = backColor == new ColorValue( 0, 0, 0, 0 );
//!!!!неправильной текстурой рисовать, чтобы видно было что ошибка? везде так
//!!!!!заранее при загрузке?
Component_Image texture = SourceImage;
////!!!!?
//GpuTexture gpuTexture = ResourceUtils.GetTextureCompiledData( texture );
//if( gpuTexture == null )
// gpuTexture = ResourceUtils.GetTextureCompiledData( ResourceUtils.WhiteTexture2D );
if (texture != null)
{
//Rect texCoord = backTextureCoord;
//if( backTextureTile && texture != null )
//{
// double baseHeight = UIControlsWorld.ScaleByResolutionBaseHeight;
// //!!!!!!slow
// Vec2 tileCount = new Vec2( baseHeight * renderer.AspectRatio, baseHeight ) / gpuTexture.SourceSize.ToVec2F() * GetScreenSize();
// texCoord = new Rect( -tileCount * .5f, tileCount * .5f ) + new Vec2( .5f, .5f );
//}
//var color = GetTotalColorMultiplier();
//if( color.Alpha > 0 )
//{
// color.Saturate();
GetScreenRectangle(out var rect);
var filtering = Filtering.Value;
//!!!!или всегда выставлять. или добавить пункт Default.
if (filtering == CanvasRenderer.TextureFilteringMode.Point)
{
renderer.PushTextureFilteringMode(CanvasRenderer.TextureFilteringMode.Point);
}
renderer.AddQuad(rect, TextureCoordinates.Value, texture, ColorValue.One, Clamp);
//renderer.AddQuad( rect, texCoord, texture, color, backTextureTile ? false : true );
if (filtering == CanvasRenderer.TextureFilteringMode.Point)
{
renderer.PopTextureFilteringMode();
}
//}
}
}
//!!!!
//int numMipmaps;
//bool isAlpha;
//virtual void _setTextureLayerAnisotropy( size_t unit, unsigned int maxAnisotropy ) = 0;
//virtual void _setTextureMipmapBias( size_t unit, float bias ) = 0;
//public ContentTypes contentType;
//bool fetch4;
//public TextureParameterValue()
//{
//}
//public TextureParameterValue( Component_Image texture, TextureAddressingMode addressingMode, FilterOption filteringMin, FilterOption filteringMag, FilterOption filteringMip, ColorValue borderColor )
//{
// this.texture = texture;
// this.addressingMode = addressingMode;
// this.filteringMin = filteringMin;
// this.filteringMag = filteringMag;
// this.filteringMip = filteringMip;
// this.borderColor = borderColor;
//}
public BindTextureData(int textureUnit, Component_Image texture, TextureAddressingMode addressingMode, FilterOption filteringMin, FilterOption filteringMag, FilterOption filteringMip)
{
this.TextureUnit = textureUnit;
this.Texture = texture;
this.AddressingMode = addressingMode;
this.FilteringMin = filteringMin;
this.FilteringMag = filteringMag;
this.FilteringMip = filteringMip;
this.BorderColor = new ColorValue(0, 0, 0, 0);
this.AdditionFlags = 0;
}
//private void Viewport_UpdateBegin( Viewport viewport )
//{
// //generator?.PerformUpdate();
//}
void Shutdown()
{
if (imageData != IntPtr.Zero)
{
NativeUtility.Free(imageData);
imageData = IntPtr.Zero;
}
texture?.Dispose();
texture = null;
viewport = null;
textureRead?.Dispose();
textureRead = null;
}
protected override void OnDisabled()
{
RenderingSystem.RenderSystemEvent -= RenderSystem_RenderSystemEvent;
DestroyBrowser();
//never called
//WebCore.Shutdown();
if (texture != null)
{
texture.Dispose();
texture = null;
}
}
void Clear()
{
compiledCode = "";
compiledScript = null;
compiledMembers.Clear();
compiledMemberBySignature.Clear();
//One method mode
compiledOneMethod = null;
properties.Clear();
propertyBySignature.Clear();
propertyMethodParameters = null;
propertyMethodReturnParameter = null;
// clear cached texture for flow graph
cachedFlowGraphNodeImage?.Dispose();
cachedFlowGraphNodeImage = null;
}
void UpdateProcessedCubemaps()
{
if (processedEnvironmentCubemap != null && processedEnvironmentCubemap.Disposed)
{
processedEnvironmentCubemap = null;
processedCubemapNeedUpdate = true;
}
if (processedIrradianceCubemap != null && processedIrradianceCubemap.Disposed)
{
processedIrradianceCubemap = null;
processedCubemapNeedUpdate = true;
}
if (processedCubemapNeedUpdate && AllowProcessEnvironmentCubemap)
{
processedCubemapNeedUpdate = false;
ProcessCubemaps();
}
}
/////////////////////////////////////////
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
context.objectsDuringUpdate.namedTextures.TryGetValue("motionTexture", out var motionTexture);
if (motionTexture != null)
{
//create final
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
var shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\MotionBlur_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"motionTexture"*/, motionTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("intensity", (float)Intensity);
var multiplier = 0.0;
if (context.Owner.LastUpdateTimeStep != 0)
{
multiplier = (1.0 / context.Owner.LastUpdateTimeStep) / 45.0;
}
multiplier *= Multiplier.Value;
//fix initial rattling
if (context.Owner.LastUpdateTimeStep > 0.1)
{
multiplier = 0;
}
shader.Parameters.Set("motionBlurMultiplier", (float)multiplier);
var size = actualTexture.Result.ResultSize;
shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(actualTexture);
//update actual texture
actualTexture = finalTexture;
}
}
public void Render(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
OnRender(context, frameData, ref actualTexture);
RenderEvent?.Invoke(this, context, frameData, ref actualTexture);
}
/////////////////////////////////////////
protected virtual void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
}
/////////////////////////////////////////
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
//blur
var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
var blurTexture = pipeline.GaussianBlur(context, this, actualTexture, BlurFactor, BlurDownscalingMode, BlurDownscalingValue);
//context.RenderTarget_Free( brightTexture );
////horizontal blur
//var texture1 = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, actualTexture.Result.Format );
//{
// context.SetViewport( texture1.Result.GetRenderTarget().Viewports[ 0 ] );
// CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
// shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
// shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";
// //shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Blur_fs.sc";
// shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );
// BlurSetShaderParameters( context, shader, true );
// context.RenderQuadToCurrentViewport( shader );
//}
////vertical blur
//var blurTexture = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, texture1.Result.Format );
//{
// context.SetViewport( blurTexture.Result.GetRenderTarget().Viewports[ 0 ] );
// CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
// shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
// shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";
// //shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Blur_fs.sc";
// shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( texture1,
// TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
// BlurSetShaderParameters( context, shader, false );
// context.RenderQuadToCurrentViewport( shader );
//}
////free old texture
//context.RenderTarget_Free( texture1 );
//create final
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, blurTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Final_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"blurTexture"*/, blurTexture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out Component_Image depthTexture);
if (depthTexture == null)
{
//!!!!
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2 /*"depthTexture"*/, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
Vector4 properties = new Vector4(FocalDistance, FocalSize, BackgroundTransitionLength, BlurForeground ? ForegroundTransitionLength : -1);
shader.Parameters.Set("u_depthOfFieldProperties", properties.ToVector4F());
shader.Parameters.Set("intensity", (float)Intensity);
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(actualTexture);
context.DynamicTexture_Free(blurTexture);
//update actual texture
actualTexture = finalTexture;
}
public Component_Image GetImage(out long uniqueMaskDataCounter)
{
uniqueMaskDataCounter = 0;
if (MaskImage.Value != null)
{
return(MaskImage);
}
else if (Mask.Value != null && Mask.Value.Length != 0)
{
if (EnabledInHierarchy)
{
if (createdMaskImage == null)
{
int textureSize = (int)Math.Sqrt(Mask.Value.Length);
//need set ShowInEditor = false before AddComponent
var texture = ComponentUtility.CreateComponent <Component_Image>(null, false, false);
texture.DisplayInEditor = false;
AddComponent(texture, -1);
//var texture = CreateComponent<Component_Image>( enabled: false );
texture.SaveSupport = false;
texture.CloneSupport = false;
//!!!!
bool mipmaps = false;
texture.CreateType = Component_Image.TypeEnum._2D;
texture.CreateSize = new Vector2I(textureSize, textureSize);
texture.CreateMipmaps = mipmaps;
texture.CreateFormat = PixelFormat.L8;
var usage = Component_Image.Usages.WriteOnly;
if (mipmaps)
{
usage |= Component_Image.Usages.AutoMipmaps;
}
texture.CreateUsage = usage;
texture.Enabled = true;
createdMaskImage = texture;
createdMaskImageNeedUpdate = true;
}
//update data
if (createdMaskImageNeedUpdate)
{
GpuTexture gpuTexture = createdMaskImage.Result;
if (gpuTexture != null)
{
var d = new GpuTexture.SurfaceData[] { new GpuTexture.SurfaceData(0, 0, Mask.Value) };
gpuTexture.SetData(d);
}
createdMaskImageNeedUpdate = false;
}
uniqueMaskDataCounter = this.uniqueMaskDataCounter;
return(createdMaskImage);
}
}
return(null);
}
public void DestroyCreatedMaskImage()
{
createdMaskImage?.Dispose();
createdMaskImage = null;
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
var result = Result as CompiledDataSimple;
//!!!!так?
if (result == null)
{
return;
}
if (result.vertexProgram == null || result.fragmentProgram == null)
{
return;
}
//!!!!валится если файла нет. или не указан.
//!!!!!!как быстро проверять о том что файла нет? может из кеша шейдеров или типа того. как тогда обновлять
//string shaderFile = Shader;
//if( string.IsNullOrEmpty( shaderFile ) )
// return;
//!!!!formats. т.е. эффект поддерживает и LDR и HDR. где еще
//!!!!!можно по сути у эффекта указывать что он ожидает получить на входе. ну или это EffectsHDR, EffectsLDR
var outputTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
context.SetViewport(outputTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.CompiledVertexProgram = result.vertexProgram;
shader.CompiledFragmentProgram = result.fragmentProgram;
//shader.VertexProgramFileName = shaderFile;
//shader.VertexProgramFunctionName = "main_vp";
//shader.FragmentProgramFileName = shaderFile;
//shader.FragmentProgramFunctionName = "main_fp";
//{
// var defines = new List<GuiRenderer.ShaderItem.DefineItem>();
// //defines.Add( new GuiRenderer.ShaderItem.DefineItem( "FRAGMENT_CODE_BODY", "color = float4(0,1,0,1);" ) );
// if( defines.Count != 0 )
// shader.Defines = defines.ToArray();
//}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
actualTexture, TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
//shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );
var size = actualTexture.Result.ResultSize;
shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());
//!!!!типы
//bool, int, uint, dword, half, float, double
//Vec2, Vec3, Vec4, VecxF, Mat2, 3, 4
//Texture
//Structs
//arrays?
//Structured Buffer
//byte buffers
//set shader parameters by properties
foreach (var m in MetadataGetMembers())
{
var p = m as Metadata.Property;
if (p != null)
{
if (CanBeShaderParameter(this, p, out object value))
{
Component_Image texture = value as Component_Image;
if (texture != null)
{
foreach (Component_Image.BindSettingsAttribute attr in
p.GetCustomAttributes(typeof(Component_Image.BindSettingsAttribute), true))
{
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(attr.SamplerIndex,
texture, attr.AddressingMode, attr.FilteringMin, attr.FilteringMag, attr.FilteringMip));
break;
}
//GpuMaterialPass.TextureParameterValue textureValue = null;
//int samplerIndex = -1;
//foreach( Component_Image.BindSettingsAttribute attr in p.GetCustomAttributes(
// typeof( Component_Image.BindSettingsAttribute ), true ) )
//{
// textureValue = new GpuMaterialPass.TextureParameterValue( texture,
// attr.AddressingMode, attr.FilteringMin, attr.FilteringMag, attr.FilteringMip );
// samplerIndex = attr.SamplerIndex;
// break;
//}
//if( samplerIndex != -1 )
// shader.Parameters.Set( samplerIndex.ToString(), textureValue );
}
else
{
//!!!!
//convert to float type
value = SimpleTypes.ConvertDoubleToFloat(value);
//ColorValuePowered: convert to ColorValue
if (value is ColorValuePowered)
{
value = ((ColorValuePowered)value).ToColorValue();
}
shader.Parameters.Set(p.Name, value);
shader.Parameters.Set(ToLowerFirstCharacter(p.Name), value);
}
}
}
}
OnSetShaderParameters(context, frameData, actualTexture, shader);
SetShaderParametersEvent?.Invoke(this, context, shader);
context.RenderQuadToCurrentViewport(shader);
//change actual texture
context.DynamicTexture_Free(actualTexture);
actualTexture = outputTexture;
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
//create final
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ShowRenderTarget_fs.sc";
string textureName = "";
switch (Texture.Value)
{
case TextureType.Normal: textureName = "normalTexture"; break;
case TextureType.Depth: textureName = "depthTexture"; break;
case TextureType.MotionVector: textureName = "motionTexture"; break;
}
context.objectsDuringUpdate.namedTextures.TryGetValue(textureName, out var showTexture);
if (showTexture == null)
{
context.DynamicTexture_Free(finalTexture);
return;
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"showTexture"*/, showTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("nearClipDistance", (float)context.Owner.CameraSettings.NearClipDistance);
shader.Parameters.Set("farClipDistance", (float)context.Owner.CameraSettings.FarClipDistance);
shader.Parameters.Set("mode", (float)Texture.Value);
shader.Parameters.Set("depthMultiplier", (float)DepthMultiplier);
shader.Parameters.Set("motionMultiplier", (float)MotionMultiplier);
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(actualTexture);
//update actual texture
actualTexture = finalTexture;
}
protected virtual void OnSetShaderParameters(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, Component_Image actualTexture, CanvasRenderer.ShaderItem shader)
{
}
/////////////////////////////////////////
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
//create final
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\EdgeDetection_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
//if( depthTexture == null )
//{
//}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"depthTexture"*/, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
if (normalTexture == null)
{
normalTexture = ResourceUtility.WhiteTexture2D;
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2 /*"normalTexture"*/, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("depthThreshold", (float)DepthThreshold);
shader.Parameters.Set("normalsThreshold", (float)NormalsThreshold);
shader.Parameters.Set("edgeColor", EdgeColor.Value.ToVector4F());
shader.Parameters.Set("thickness", (float)Thickness);
shader.Parameters.Set("maxDistance", (float)MaxDistance);
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(actualTexture);
//update actual texture
actualTexture = finalTexture;
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
var pipeline = context.RenderingPipeline as Component_RenderingPipeline_Basic;
if (pipeline == null)
{
return;
}
var frameData2 = frameData as Component_RenderingPipeline_Basic.FrameData;
if (frameData2 == null)
{
return;
}
if (Intensity.Value == 0)
{
return;
}
bool skip = true;
foreach (var lightIndex in frameData2.LightsInFrustumSorted)
{
var lightItem = frameData2.Lights[lightIndex];
if (lightItem.data.children != null)
{
foreach (var child in lightItem.data.children)
{
var lensFlares = child as Component_LensFlares;
if (lensFlares != null)
{
skip = false;
break;
}
}
}
}
if (skip)
{
return;
}
//init context data
ViewportRenderingContextData contextData;
if (context.anyData.TryGetValue("LensEffects", out var contextData2))
{
contextData = (ViewportRenderingContextData)contextData2;
}
else
{
contextData = new ViewportRenderingContextData();
context.anyData["LensEffects"] = contextData;
}
//update context data light items
contextData.Update(context.Owner.LastUpdateTimeStep, Intensity, FadeSpeed);
//create copy
var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat, createSimple3DRenderer: true, createCanvasRenderer: true);
var viewport = newTexture.Result.GetRenderTarget().Viewports[0];
//!!!!double precision
Matrix4F viewMatrix = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
context.SetViewport(viewport, viewMatrix, projectionMatrix);
pipeline.CopyToCurrentViewport(context, actualTexture);
var simple3DRenderer = viewport.Simple3DRenderer;
var canvasRenderer = viewport.CanvasRenderer;
//render
foreach (var lightIndex in frameData2.LightsInFrustumSorted)
{
var lightItem = frameData2.Lights[lightIndex];
if (lightItem.data.children != null)
{
foreach (var child in lightItem.data.children)
{
var lensFlares = child as Component_LensFlares;
if (lensFlares != null)
{
var light = lightItem.data.Creator as Component_Light;
if (light != null)
{
CheckVisibilityScreenPosition(context, lightItem.data.Position, out var gotScreenPosition, out var insideScreen);
if (gotScreenPosition)
{
//update
{
switch (CheckVisibilityMethod.Value)
{
case CheckVisibilityMethodEnum.OcclusionQuery:
{
var parameter = (contextData, light);
if (RenderingSystem.TryCreateOcclusionQuery(OcclusionQueryCallback, parameter, out var query))
{
var thickness = context.Owner.Simple3DRenderer.GetThicknessByPixelSize(lightItem.data.Position, 5);
var bounds = new Bounds(lightItem.data.Position);
bounds.Expand(thickness * 0.5);
simple3DRenderer.SetColor(new ColorValue(1, 0, 0));
simple3DRenderer.SetOcclusionQuery(query);
simple3DRenderer.AddBounds(bounds, true);
//simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 4, true );
simple3DRenderer.SetOcclusionQuery(null);
}
}
break;
case CheckVisibilityMethodEnum.PhysicsRayCast:
if (CheckVisibilityPhysics(context, lightItem.data.Position))
{
contextData.UpdateLastTimeVisible(light);
}
break;
}
}
//render
var intensity = contextData.GetIntensity(light);
if (intensity > 0)
{
//simple3DRenderer.SetColor( new ColorValue( 1, 0, 0 ) );
//simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 10, true );
lensFlares.RenderUI(canvasRenderer, lightItem.data, context.Owner, intensity);
}
}
else
{
contextData.Remove(light);
}
}
}
}
}
}
//render
if (simple3DRenderer._ViewportRendering_PrepareRenderables())
{
simple3DRenderer._ViewportRendering_RenderToCurrentViewport(context);
simple3DRenderer._Clear();
}
canvasRenderer._ViewportRendering_RenderToCurrentViewport(context, true, context.Owner.LastUpdateTime);
//free old textures
context.DynamicTexture_Free(actualTexture);
//update actual texture
actualTexture = newTexture;
}
//private void Pipeline_RenderBegin( Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData )
//{
// if( EnabledInHierarchy && sender.UseRenderTargets )
// {
// //frameData.GenerateIBLSpecularTexture = true;
// //frameData.DeferredSpecularIBLItensity = 1.0 - Intensity;
// }
//}
private void Pipeline_RenderDeferredShadingEnd(Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData, ref Component_Image sceneTexture)
{
if (EnabledInHierarchy && sender.GetUseMultiRenderTargets())
{
var actualTexture = sceneTexture;
var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
Vector3 cameraPos = context.Owner.CameraSettings.Position;
//!!!!double
Vector3F cameraPosition = cameraPos.ToVector3F();
//!!!!double
Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
Matrix4F viewMatrix = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
Matrix4F viewProjMatrix = projectionMatrix * viewMatrix;
Matrix4F invViewProjMatrix = viewProjMatrix.GetInverse();
float aspectRatio = (float)context.Owner.CameraSettings.AspectRatio;
float fov = (float)context.Owner.CameraSettings.FieldOfView;
float zNear = (float)context.Owner.CameraSettings.NearClipDistance;
float zFar = (float)context.Owner.CameraSettings.FarClipDistance;
var ambientLight = frameData.Lights[frameData.LightsInFrustumSorted[0]];
var ambientLightPower = ambientLight.data.Power;
var reflectionTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(reflectionTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_fs.sc";
int maxSteps = 50;
switch (Quality.Value)
{
case QualityEnum.Lowest: maxSteps = 20; break;
case QualityEnum.Low: maxSteps = 50; break;
case QualityEnum.Medium: maxSteps = 80; break;
case QualityEnum.High: maxSteps = 120; break;
case QualityEnum.Highest: maxSteps = 160; break;
}
shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem("MAX_STEPS", maxSteps.ToString()));
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
//!!!часть параметров есть UniformsGeneral.sh
shader.Parameters.Set("viewProj", viewProjMatrix);
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("edgeFactorPower", (float)EdgeFactorPower);
shader.Parameters.Set("colorTextureSize", new Vector4F((float)actualTexture.Result.ResultSize.X, (float)actualTexture.Result.ResultSize.Y, 0.0f, 0.0f));
shader.Parameters.Set("zNear", zNear);
shader.Parameters.Set("zFar", zFar);
shader.Parameters.Set("fov", fov);
shader.Parameters.Set("aspectRatio", aspectRatio);
context.RenderQuadToCurrentViewport(shader);
}
var min = BlurRoughnessMin.Value;
var max = BlurRoughnessMax.Value;
if (min > max)
{
min = max;
}
var blurRoughnessMin = pipeline.GaussianBlur(context, this, reflectionTexture, min, BlurDownscalingMode, BlurDownscalingValue);
var blurRoughnessMax = pipeline.GaussianBlur(context, this, reflectionTexture, max, BlurDownscalingMode, BlurDownscalingValue);
//// Blur Pass:
//var bluredReflection = pipeline.GaussianBlur( context, this, reflectionTexture, BlurFactorOnMaxRoughness, BlurDownscalingMode, BlurDownscalingValue );
// Final Pass:
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_Apply_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);
//!!!!reflection probes?
pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, blurRoughnessMin,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, blurRoughnessMax,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//shader.Parameters.Set( "1", new GpuMaterialPass.TextureParameterValue( reflectionTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
//shader.Parameters.Set( "2", new GpuMaterialPass.TextureParameterValue( bluredReflection,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, normalTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
//!!!!rotation, multiplier
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, environmentTexture.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, environmentTextureIBL.Value.texture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, Component_RenderingPipeline_Basic.BrdfLUT,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, gBuffer2Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(9, gBuffer0Texture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
shader.Parameters.Set("invViewProj", invViewProjMatrix);
shader.Parameters.Set("cameraPosition", cameraPosition);
shader.Parameters.Set("intensity", (float)Intensity);
shader.Parameters.Set("ambientLightPower", ambientLightPower);
context.RenderQuadToCurrentViewport(shader);
}
// Free Targets:
context.DynamicTexture_Free(reflectionTexture);
context.DynamicTexture_Free(blurRoughnessMin);
context.DynamicTexture_Free(blurRoughnessMax);
//context.RenderTarget_Free( bluredReflection );
context.DynamicTexture_Free(actualTexture);
// Update actual Texture:
actualTexture = finalTexture;
//result
sceneTexture = actualTexture;
}
}
//!!!!
//!!!!need per camera context
//double smoothIntensityFactorLastUpdate;
//double? smoothIntensityFactor;
/////////////////////////////////////////
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
base.OnRender(context, frameData, ref actualTexture);
var cameraSettings = context.Owner.CameraSettings;
bool lightFound = false;
Vector3 lightPosition = Vector3.Zero;
if (OverrideDirection.Value != Vector3.Zero)
{
lightFound = true;
lightPosition = cameraSettings.Position - OverrideDirection.Value.GetNormalize() * cameraSettings.FarClipDistance;
}
else
{
if (Light.ReferenceSpecified)
{
var light = Light.Value;
if (light != null)
{
lightFound = true;
if (light.Type.Value == Component_Light.TypeEnum.Directional)
{
lightPosition = cameraSettings.Position - light.TransformV.Rotation.GetForward() * cameraSettings.FarClipDistance;
}
else
{
lightPosition = light.TransformV.Position;
}
}
}
else
{
var frameData2 = frameData as Component_RenderingPipeline_Basic.FrameData;
if (frameData2 != null)
{
foreach (var lightIndex in frameData2.LightsInFrustumSorted)
{
var item = frameData2.Lights[lightIndex];
if (item.data.Type == Component_Light.TypeEnum.Directional)
{
lightFound = true;
lightPosition = cameraSettings.Position - item.data.Rotation.GetForward() * (float)cameraSettings.FarClipDistance;
break;
}
}
}
}
}
if (!lightFound)
{
return;
}
if (!context.Owner.CameraSettings.ProjectToScreenCoordinates(lightPosition, out var screenLightPosition))
{
return;
}
//calculate intensity factor by the sun position on the screen.
double demandIntensityFactor = 0;
{
Degree angle = 0;
if (lightPosition != cameraSettings.Position)
{
angle = MathAlgorithms.GetVectorsAngle(cameraSettings.Rotation.GetForward(),
(lightPosition - cameraSettings.Position).GetNormalize()).InDegrees();
}
else
{
angle = 10000;
}
var curve = new CurveLine();
curve.AddPoint(0, new Vector3(1, 0, 0));
curve.AddPoint(60, new Vector3(1, 0, 0));
curve.AddPoint(75, new Vector3(0, 0, 0));
curve.AddPoint(90, new Vector3(0, 0, 0));
var angleFactor = curve.CalculateValueByTime(angle).X;
var curve2 = new CurveLine();
curve2.AddPoint(-0.2, new Vector3(0, 0, 0));
curve2.AddPoint(-0.1, new Vector3(1, 0, 0));
curve2.AddPoint(1.1, new Vector3(1, 0, 0));
curve2.AddPoint(1.2, new Vector3(0, 0, 0));
var heightFactor = curve2.CalculateValueByTime(screenLightPosition.Y).X;
demandIntensityFactor = angleFactor * heightFactor;
//const float screenFadingBorder = .1f;
//double minDistance = 1;
//for( int axis = 0; axis < 2; axis++ )
//{
// if( screenLightPosition[ axis ] < screenFadingBorder )
// {
// var d = screenLightPosition[ axis ];
// if( d < minDistance )
// minDistance = d;
// }
// else if( screenLightPosition[ axis ] > 1.0f - screenFadingBorder )
// {
// var d = 1.0f - screenLightPosition[ axis ];
// if( d < minDistance )
// minDistance = d;
// }
//}
//needIntensityFactor = minDistance / screenFadingBorder;
//MathEx.Saturate( ref needIntensityFactor );
////clamp screenLightPosition
//if( !new Rectangle( 0, 0, 1, 1 ).Contains( screenLightPosition ) )
//{
// if( MathAlgorithms.IntersectRectangleLine( new Rectangle( .0001f, .0001f, .9999f, .9999f ),
// new Vector2( .5f, .5f ), screenLightPosition, out var intersectPoint1, out var intersectPoint2 ) != 0 )
// {
// screenLightPosition = intersectPoint1;
// }
//}
}
var smoothIntensityFactor = demandIntensityFactor;
////update smooth intensity factor
//if( smoothIntensityFactor == null )
// smoothIntensityFactor = needIntensityFactor;
//if( smoothIntensityFactorLastUpdate != context.Owner.LastUpdateTime )
//{
// smoothIntensityFactorLastUpdate = context.Owner.LastUpdateTime;
// const double smoothSpeed = 1;
// var step = context.Owner.LastUpdateTimeStep * smoothSpeed;
// if( needIntensityFactor > smoothIntensityFactor )
// {
// smoothIntensityFactor += step;
// if( smoothIntensityFactor > needIntensityFactor )
// smoothIntensityFactor = needIntensityFactor;
// }
// else
// {
// smoothIntensityFactor -= step;
// if( smoothIntensityFactor < needIntensityFactor )
// smoothIntensityFactor = needIntensityFactor;
// }
//}
//get result intensity
var resultIntensity = Intensity.Value * smoothIntensityFactor;
if (resultIntensity <= 0)
{
return;
}
double divisor = 9.0 - Resolution;
if (divisor <= 1)
{
divisor = 1;
}
var sizeFloat = actualTexture.Result.ResultSize.ToVector2() / divisor;
var size = new Vector2I((int)sizeFloat.X, (int)sizeFloat.Y);
//scattering pass
var scatteringTexture = context.RenderTarget2D_Alloc(size, PixelFormat.A8R8G8B8); //!!!! PixelFormat.R8G8B8 );
{
context.SetViewport(scatteringTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Scattering_fs.sc";
context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
if (depthTexture == null)
{
//!!!!
}
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"depthTexture"*/, depthTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set("screenLightPosition", screenLightPosition.ToVector2F());
shader.Parameters.Set("decay", (float)Decay);
shader.Parameters.Set("density", (float)Density);
context.RenderQuadToCurrentViewport(shader);
}
//blur pass
var blurTexture = context.RenderTarget2D_Alloc(size, PixelFormat.A8R8G8B8); //!!!! PixelFormat.R8G8B8 );
{
context.SetViewport(blurTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Blur_fs.sc";
//!!!!Linear?
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"scatteringTexture"*/, scatteringTexture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
shader.Parameters.Set("color", Color.Value.ToVector3F());
shader.Parameters.Set("screenLightPosition", screenLightPosition.ToVector2F());
shader.Parameters.Set("blurFactor", (float)BlurFactor);
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(scatteringTexture);
//create final
var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
{
context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Final_fs.sc";
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"blurTexture"*/, blurTexture,
TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
shader.Parameters.Set("intensity", (float)resultIntensity);
context.RenderQuadToCurrentViewport(shader);
}
//free old textures
context.DynamicTexture_Free(actualTexture);
context.DynamicTexture_Free(blurTexture);
//update actual texture
actualTexture = finalTexture;
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
if (Technique.Value != TechniqueEnum.None)
{
if (Technique.Value == TechniqueEnum.FXAA)
{
RenderFXAA(context, frameData, ref actualTexture, Intensity);
}
else
{
RenderDownscale(context, frameData, actualTexture.Result.ResultSize, ref actualTexture);
}
}
}
protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
{
var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
pipeline.ConvertToLDR(context, ref actualTexture);
//var demandFormat = PixelFormat.A8R8G8B8;
//if( actualTexture.Result.Format != demandFormat )
//{
// var newTexture = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, demandFormat );
// context.SetViewport( newTexture.Result.GetRenderTarget().Viewports[ 0 ] );
// CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
// shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
// //shader.VertexProgramFunctionName = "main_vp";
// shader.FragmentProgramFileName = @"Base\Shaders\Effects\ToLDR_fs.sc";
// //shader.FragmentProgramFunctionName = "main_fp";
// shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
// TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
// //var size = context.owner.DimensionsInPixels.Size;
// //shader.Parameters.Set( "viewportSize", new Vec4( size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y ).ToVec4F() );
// //Mat4F identity = Mat4F.Identity;
// //shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );
// context.RenderQuadToCurrentViewport( shader );
// //free old texture
// context.RenderTarget_Free( actualTexture );
// actualTexture = newTexture;
//}
}
public void RenderDownscale(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, Vector2I destinationSize, ref Component_Image actualTexture)
{
if (Technique.Value >= TechniqueEnum.SSAAx2 && Technique.Value <= TechniqueEnum.SSAAx4 && context.Owner.SizeInPixels != actualTexture.Result.ResultSize)
{
var rescaledTexture = context.RenderTarget2D_Alloc(context.Owner.SizeInPixels, actualTexture.Result.ResultFormat);
//copy to scene texture with downscale
{
context.SetViewport(rescaledTexture.Result.GetRenderTarget().Viewports[0]);
CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
shader.FragmentProgramFileName = @"Base\Shaders\Effects\DownscaleAntialiasing_fs.sc";
shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem(Technique.Value.ToString().ToUpper()));
var multiplier = new Vector2F(1, 1) / destinationSize.ToVector2F() * (float)DownscaleSamplerMultiplier.Value;
shader.Parameters.Set("antialiasing_multiplier", multiplier);
shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
actualTexture, TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
context.RenderQuadToCurrentViewport(shader);
}
context.DynamicTexture_Free(actualTexture);
actualTexture = rescaledTexture;
}
}
