private void CheckInternalLogLut()
{
if (m_InternalLogLut == null || !m_InternalLogLut.IsCreated())
{
RuntimeUtilities.Destroy(m_InternalLogLut);
RenderTextureFormat lutFormat = GetLutFormat();
m_InternalLogLut = new RenderTexture(33, 33, 0, lutFormat, RenderTextureReadWrite.Linear)
{
name = "Color Grading Log Lut",
dimension = TextureDimension.Tex3D,
hideFlags = HideFlags.DontSave,
filterMode = FilterMode.Bilinear,
wrapMode = TextureWrapMode.Clamp,
anisoLevel = 0,
enableRandomWrite = true,
volumeDepth = 33,
autoGenerateMips = false,
useMipMap = false
};
m_InternalLogLut.Create();
}
}
private static CommandLineRunner CreateRunner(
string[] args = null,
string input = "",
string responseFile = null,
string workingDirectory = null)
{
var io = new TestConsoleIO(input);
var clientDir = Path.GetDirectoryName(RuntimeUtilities.GetAssemblyLocation(typeof(CommandLineRunnerTests)));
var buildPaths = new BuildPaths(
clientDir: clientDir,
workingDir: workingDirectory ?? clientDir,
sdkDir: null,
tempDir: Path.GetTempPath());
var compiler = new CSharpInteractiveCompiler(
responseFile,
buildPaths,
args?.Where(a => a != null).ToArray() ?? s_defaultArgs,
new NotImplementedAnalyzerLoader());
return(new CommandLineRunner(io, compiler, CSharpScriptCompiler.Instance, CSharpObjectFormatter.Instance));
}
internal MockCSharpCompiler CreateCSharpCompiler(
string responseFile,
string workingDirectory,
string[] args,
ImmutableArray <DiagnosticAnalyzer> analyzers = default,
ImmutableArray <ISourceGenerator> generators = default,
AnalyzerAssemblyLoader loader = null
)
{
var buildPaths = RuntimeUtilities.CreateBuildPaths(
workingDirectory,
sdkDirectory: SdkDirectory
);
return(new MockCSharpCompiler(
responseFile,
buildPaths,
args,
analyzers,
generators,
loader
));
}
private void DisplayHealthToUI()
{
var currentHealthAmount = playerHealthSetter.GetCurrentHealth();
var maxHealthAmount = playerHealthSetter.maxHealthAmount;
var healthRatio = currentHealthAmount / maxHealthAmount;
if (healthRatio <= 0.5f)
{
if (!_postProcessOverrideApplied)
{
CreateOverrideVignetteEffect();
_postProcessVolume = PostProcessManager.instance.QuickVolume(
PostProcessLayer,
PostProcessOverridePriority,
_healthVignette
);
_postProcessOverrideApplied = true;
}
_healthVignette.color.value = Color.Lerp(
Color.black,
minHealthColor,
ExtensionFunctions.Map(healthRatio, 0, 0.5f, 1, 0.25f)
);
}
else if (healthRatio > 0.5f && _postProcessOverrideApplied)
{
RuntimeUtilities.DestroyVolume(_postProcessVolume, true);
_postProcessOverrideApplied = false;
}
healthFiller.color = healthRatio <= 0.5f
? Color.Lerp(minHealthColor, halfHealthColor, healthRatio * 2)
: Color.Lerp(halfHealthColor, maxHealthColor, (healthRatio - 0.5f) * 2);
healthSlider.value = healthRatio;
}
public void Init(PostProcessProfile asset, SerializedObject serializedObject)
{
Assert.IsNotNull(asset);
Assert.IsNotNull(serializedObject);
this.asset = asset;
m_SerializedObject = serializedObject;
m_SettingsProperty = serializedObject.FindProperty("settings");
Assert.IsNotNull(m_SettingsProperty);
m_EditorTypes = new Dictionary <Type, Type>();
m_Editors = new List <PostProcessEffectBaseEditor>();
// Gets the list of all available postfx editors
var editorTypes = RuntimeUtilities.GetAllAssemblyTypes()
.Where(
t => t.IsSubclassOf(typeof(PostProcessEffectBaseEditor)) &&
t.IsDefined(typeof(PostProcessEditorAttribute), false) &&
!t.IsAbstract
);
// Map them to their corresponding settings type
foreach (var editorType in editorTypes)
{
var attribute = editorType.GetAttribute <PostProcessEditorAttribute>();
m_EditorTypes.Add(attribute.settingsType, editorType);
}
// Create editors for existing settings
for (int i = 0; i < this.asset.settings.Count; i++)
{
CreateEditor(this.asset.settings[i], m_SettingsProperty.GetArrayElementAtIndex(i));
}
// Keep track of undo/redo to redraw the inspector when that happens
Undo.undoRedoPerformed += OnUndoRedoPerformed;
}
public override void Render(PostProcessRenderContext context)
{
OutlineResources resources;
if (settings.Resources.value)
{
resources = settings.Resources;
}
else
{
if (!_defaultResources)
{
_defaultResources = ScriptableObject.CreateInstance <OutlineResources>();
_defaultResources.ResetToDefaults();
_defaultResources.FullscreenTriangleMesh = RuntimeUtilities.fullscreenTriangle;
}
resources = _defaultResources;
}
if (resources && resources.IsValid)
{
RuntimeUtilities.CopyTexture(context.command, context.source, context.destination);
using (var renderer = new OutlineRenderer(context.command, resources, context.destination, context.camera.actualRenderingPath, new Vector2Int(context.width, context.height)))
{
_objects.Clear();
settings.Layers.value.GetRenderObjects(_objects);
foreach (var obj in _objects)
{
renderer.Render(obj);
}
}
}
}
public override void Render(PostProcessRenderContext context)
{
float realtimeSinceStartup = Time.realtimeSinceStartup;
float z = HaltonSeq.Get(m_SampleIndex & 0x3FF, 2);
float w = HaltonSeq.Get(m_SampleIndex & 0x3FF, 3);
if (++m_SampleIndex >= 1024)
{
m_SampleIndex = 0;
}
if (m_GrainLookupRT == null || !m_GrainLookupRT.IsCreated())
{
RuntimeUtilities.Destroy(m_GrainLookupRT);
m_GrainLookupRT = new RenderTexture(128, 128, 0, GetLookupFormat())
{
filterMode = FilterMode.Bilinear,
wrapMode = TextureWrapMode.Repeat,
anisoLevel = 0,
name = "Grain Lookup Texture"
};
m_GrainLookupRT.Create();
}
PropertySheet propertySheet = context.propertySheets.Get(context.resources.shaders.grainBaker);
propertySheet.properties.Clear();
propertySheet.properties.SetFloat(ShaderIDs.Phase, realtimeSinceStartup % 10f);
context.command.BeginSample("GrainLookup");
context.command.BlitFullscreenTriangle(BuiltinRenderTextureType.None, m_GrainLookupRT, propertySheet, base.settings.colored.value ? 1 : 0);
context.command.EndSample("GrainLookup");
PropertySheet uberSheet = context.uberSheet;
uberSheet.EnableKeyword("GRAIN");
uberSheet.properties.SetTexture(ShaderIDs.GrainTex, m_GrainLookupRT);
uberSheet.properties.SetVector(ShaderIDs.Grain_Params1, new Vector2(base.settings.lumContrib.value, base.settings.intensity.value * 20f));
uberSheet.properties.SetVector(ShaderIDs.Grain_Params2, new Vector4((float)context.width / (float)m_GrainLookupRT.width / base.settings.size.value, (float)context.height / (float)m_GrainLookupRT.height / base.settings.size.value, z, w));
}
private void Render()
{
_CommandBuffer = new CommandBuffer();
_CommandBuffer.name = "AdvancedRTR";
_CommandBuffer.GetTemporaryRT(ShaderConstants._SourceRT, _Camera.pixelWidth, _Camera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
//copy
RuntimeUtilities.BuiltinBlit(_CommandBuffer, BuiltinRenderTextureType.CameraTarget, ShaderConstants._SourceRT);
//FXAA
_CommandBuffer.BeginSample("SSR");
_CommandBuffer.GetTemporaryRT(ShaderConstants._TestRT, _Camera.pixelWidth, _Camera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
RuntimeUtilities.BlitFullscreenTriangle(_CommandBuffer, ShaderConstants._SourceRT, ShaderConstants._TestRT, _SSRMat, 0);
RuntimeUtilities.BuiltinBlit(_CommandBuffer, ShaderConstants._TestRT, BuiltinRenderTextureType.CameraTarget, _BlendMat, 0);
_CommandBuffer.EndSample("SSR");
_CommandBuffer.ReleaseTemporaryRT(ShaderConstants._SourceRT);
_CommandBuffer.ReleaseTemporaryRT(ShaderConstants._TestRT);
_Camera.AddCommandBuffer(CameraPoint, _CommandBuffer);
}
public string DumpAssemblyData(out string dumpDirectory)
{
return(RuntimeUtilities.DumpAssemblyData(ModuleDatas, out dumpDirectory));
}
void OnDestroy()
{
RuntimeUtilities.DestroyVolume(v_Volume, true, true);
RuntimeUtilities.DestroyVolume(ch_Volume, true, true);
}
private static BuildPaths CreateBuildPaths(string workingDirectory, string sdkDirectory = null) => RuntimeUtilities.CreateBuildPaths(workingDirectory, sdkDirectory);
public MockCSharpCompiler(string responseFile, BuildPaths buildPaths, string[] args, ImmutableArray <DiagnosticAnalyzer> analyzers = default, AnalyzerAssemblyLoader loader = null)
: base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), loader ?? RuntimeUtilities.CreateAnalyzerAssemblyLoader())
{
_analyzers = analyzers.NullToEmpty();
}
private void DestroyVolume()
{
RuntimeUtilities.DestroyVolume(m_Volume, true, true);
Iscreate = false;
}
public override void Render(PostProcessRenderContext context)
{
PropertySheet sheet = context.propertySheets.Get(shader);
CommandBuffer cmd = context.command;
Camera cam = context.camera;
#region Skybox sampling
//Add the skybox rendering component to any camera rendering Fog
if (settings.colorSource.value == Fog.FogColorSource.SkyboxColor)
{
//Ignore hidden camera's, except scene-view cam
if (cam.hideFlags != HideFlags.None && cam.name != "SceneCamera")
{
return;
}
if (!skyboxCams.ContainsKey(cam))
{
skyboxCams[cam] = cam.gameObject.GetComponent <RenderScreenSpaceSkybox>();
if (!skyboxCams[cam])
{
skyboxCams[cam] = cam.gameObject.AddComponent <RenderScreenSpaceSkybox>();
}
skyboxCams[cam].manuallyAdded = false; //Don't show warning on component
}
}
#endregion
//OpenVR.System.GetProjectionMatrix(vrEye, mainCamera.nearClipPlane, mainCamera.farClipPlane, EGraphicsAPIConvention.API_DirectX)
//Clip-space to world-space camera matrix conversion
#region Property value composition
var p = GL.GetGPUProjectionMatrix(cam.projectionMatrix, false);
p[2, 3] = p[3, 2] = 0.0f;
p[3, 3] = 1.0f;
var clipToWorld = Matrix4x4.Inverse(p * cam.worldToCameraMatrix) * Matrix4x4.TRS(new Vector3(0, 0, -p[2, 2]), Quaternion.identity, Vector3.one);
sheet.properties.SetMatrix("clipToWorld", clipToWorld);
float FdotC = cam.transform.position.y - settings.height;
float paramK = (FdotC <= 0.0f ? 1.0f : 0.0f);
//Always exclude skybox for skybox color mode
//Always include when using light scattering to avoid depth discontinuity
float skyboxInfluence = (settings.lightScattering) ? 1.0f : settings.skyboxInfluence;
float distanceFog = (settings.distanceFog) ? 1.0f : 0.0f;
float heightFog = (settings.heightFog) ? 1.0f : 0.0f;
int colorSource = (settings.useSceneSettings) ? 0 : (int)settings.colorSource.value;
var sceneMode = (settings.useSceneSettings) ? RenderSettings.fogMode : settings.fogMode;
var sceneDensity = (settings.useSceneSettings) ? RenderSettings.fogDensity : settings.globalDensity / 100;
var sceneStart = (settings.useSceneSettings) ? RenderSettings.fogStartDistance : settings.fogStartDistance;
var sceneEnd = (settings.useSceneSettings) ? RenderSettings.fogEndDistance : settings.fogEndDistance;
bool linear = (sceneMode == FogMode.Linear);
float diff = linear ? sceneEnd - sceneStart : 0.0f;
float invDiff = Mathf.Abs(diff) > 0.0001f ? 1.0f / diff : 0.0f;
Vector4 sceneParams;
sceneParams.x = sceneDensity * 1.2011224087f; // density / sqrt(ln(2)), used by Exp2 fog mode
sceneParams.y = sceneDensity * 1.4426950408f; // density / ln(2), used by Exp fog mode
sceneParams.z = linear ? -invDiff : 0.0f;
sceneParams.w = linear ? sceneEnd * invDiff : 0.0f;
float gradientDistance = (settings.gradientUseFarClipPlane.value) ? settings.gradientDistance : context.camera.farClipPlane;
#endregion
#region Property assignment
if (settings.heightNoiseTex.value)
{
sheet.properties.SetTexture("_NoiseTex", settings.heightNoiseTex);
}
if (settings.fogColorGradient.value)
{
sheet.properties.SetTexture("_ColorGradient", settings.fogColorGradient);
}
sheet.properties.SetFloat("_FarClippingPlane", gradientDistance);
sheet.properties.SetVector("_SceneFogParams", sceneParams);
sheet.properties.SetVector("_SceneFogMode", new Vector4((int)sceneMode, settings.useRadialDistance ? 1 : 0, colorSource, settings.heightFogNoise ? 1 : 0));
sheet.properties.SetVector("_NoiseParams", new Vector4(settings.heightNoiseSize * 0.01f, settings.heightNoiseSpeed * 0.01f, settings.heightNoiseStrength, 0));
sheet.properties.SetVector("_DensityParams", new Vector4(settings.distanceDensity, settings.heightNoiseStrength, settings.skyboxMipLevel, 0));
sheet.properties.SetVector("_HeightParams", new Vector4(settings.height, FdotC, paramK, settings.heightDensity * 0.5f));
sheet.properties.SetVector("_DistanceParams", new Vector4(-sceneStart, 0f, distanceFog, heightFog));
sheet.properties.SetColor("_FogColor", (settings.useSceneSettings) ? RenderSettings.fogColor : settings.fogColor);
sheet.properties.SetVector("_SkyboxParams", new Vector4(skyboxInfluence, settings.skyboxMipLevel, 0, 0));
Vector3 sunDir = (settings.useLightDirection) ? Fog.LightDirection : settings.lightDirection.value.normalized;
float sunIntensity = (settings.useLightIntensity) ? FogLightSource.intensity : settings.lightIntensity.value;
sunIntensity = (settings.enableDirectionalLight) ? sunIntensity : 0f;
sheet.properties.SetVector("_DirLightParams", new Vector4(sunDir.x, sunDir.y, sunDir.z, sunIntensity));
Color sunColor = (settings.useLightColor) ? FogLightSource.color : settings.lightColor.value;
sheet.properties.SetVector("_DirLightColor", new Vector4(sunColor.r, sunColor.g, sunColor.b, 0));
#endregion
#region Light scattering
//Repurpose parts of the bloom effect
bool enableScattering = (settings.lightScattering) ? true : false;
if (enableScattering)
{
int tw = Mathf.FloorToInt(context.screenWidth / (2f));
int th = Mathf.FloorToInt(context.screenHeight / (2f));
bool singlePassDoubleWide = (context.stereoActive && (context.stereoRenderingMode == PostProcessRenderContext.StereoRenderingMode.SinglePass) && (context.camera.stereoTargetEye == StereoTargetEyeMask.Both));
int tw_stereo = singlePassDoubleWide ? tw * 2 : tw;
// Determine the iteration count
int s = Mathf.Max(tw, th);
float logs = Mathf.Log(s, 2f) + Mathf.Min(settings.scatterDiffusion.value, 10f) - 10f;
int logs_i = Mathf.FloorToInt(logs);
int iterations = Mathf.Clamp(logs_i, 1, k_MaxPyramidSize);
float sampleScale = 0.5f + logs - logs_i;
sheet.properties.SetFloat("_SampleScale", sampleScale);
// Prefiltering parameters
float lthresh = Mathf.GammaToLinearSpace(settings.scatterThreshold.value);
float knee = lthresh * settings.scatterSoftKnee.value + 1e-5f;
var threshold = new Vector4(lthresh, lthresh - knee, knee * 2f, 0.25f / knee);
sheet.properties.SetVector("_Threshold", threshold);
// Downsample
var lastDown = context.source;
for (int i = 0; i < iterations; i++)
{
int mipDown = m_Pyramid[i].down;
int mipUp = m_Pyramid[i].up;
int pass = i == 0 ? (int)Pass.Prefilter : (int)Pass.Downsample;
context.GetScreenSpaceTemporaryRT(cmd, mipDown, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw_stereo, th);
context.GetScreenSpaceTemporaryRT(cmd, mipUp, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw_stereo, th);
cmd.BlitFullscreenTriangle(lastDown, mipDown, sheet, pass);
lastDown = mipDown;
tw_stereo = (singlePassDoubleWide && ((tw_stereo / 2) % 2 > 0)) ? 1 + tw_stereo / 2 : tw_stereo / 2;
tw_stereo = Mathf.Max(tw_stereo, 1);
th = Mathf.Max(th / 2, 1);
}
// Upsample
int lastUp = m_Pyramid[iterations - 1].down;
for (int i = iterations - 2; i >= 0; i--)
{
int mipDown = m_Pyramid[i].down;
int mipUp = m_Pyramid[i].up;
cmd.SetGlobalTexture("_BloomTex", mipDown);
cmd.BlitFullscreenTriangle(lastUp, mipUp, sheet, (int)Pass.Upsample);
lastUp = mipUp;
}
float intensity = RuntimeUtilities.Exp2(settings.scatterIntensity.value / 10f) - 1f;
var shaderSettings = new Vector4(sampleScale, intensity, 0, iterations);
sheet.properties.SetVector("_ScatteringParams", shaderSettings);
cmd.SetGlobalTexture("_BloomTex", lastUp);
// Cleanup
for (int i = 0; i < iterations; i++)
{
if (m_Pyramid[i].down != lastUp)
{
cmd.ReleaseTemporaryRT(m_Pyramid[i].down);
}
if (m_Pyramid[i].up != lastUp)
{
cmd.ReleaseTemporaryRT(m_Pyramid[i].up);
}
}
}
#endregion
#region shader passes
context.command.BlitFullscreenTriangle(context.source, context.destination, sheet, enableScattering ? (int)Pass.BlendScattering : (int)Pass.Blend);
#endregion
}
private void OnDestroy()
{
RuntimeUtilities.DestroyVolume(volume, true, true);
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer command = context.command;
command.BeginSample("BloomPyramid");
PropertySheet propertySheet = context.propertySheets.Get(context.resources.shaders.bloom);
propertySheet.properties.SetTexture(ShaderIDs.AutoExposureTex, context.autoExposureTexture);
float num = Mathf.Clamp(base.settings.anamorphicRatio, -1f, 1f);
float num2 = (!(num < 0f)) ? 0f : (0f - num);
float num3 = (!(num > 0f)) ? 0f : num;
int num4 = Mathf.FloorToInt((float)context.screenWidth / (2f - num2));
int num5 = Mathf.FloorToInt((float)context.screenHeight / (2f - num3));
int num6 = Mathf.Max(num4, num5);
float num7 = Mathf.Log(num6, 2f) + Mathf.Min(base.settings.diffusion.value, 10f) - 10f;
int num8 = Mathf.FloorToInt(num7);
int num9 = Mathf.Clamp(num8, 1, 16);
float num10 = 0.5f + num7 - (float)num8;
propertySheet.properties.SetFloat(ShaderIDs.SampleScale, num10);
float num11 = Mathf.GammaToLinearSpace(base.settings.threshold.value);
float num12 = num11 * base.settings.softKnee.value + 1E-05f;
Vector4 value = new Vector4(num11, num11 - num12, num12 * 2f, 0.25f / num12);
propertySheet.properties.SetVector(ShaderIDs.Threshold, value);
float x = Mathf.GammaToLinearSpace(base.settings.clamp.value);
propertySheet.properties.SetVector(ShaderIDs.Params, new Vector4(x, 0f, 0f, 0f));
int num13 = base.settings.fastMode ? 1 : 0;
RenderTargetIdentifier source = context.source;
for (int i = 0; i < num9; i++)
{
int down = m_Pyramid[i].down;
int up = m_Pyramid[i].up;
int pass = (i != 0) ? (2 + num13) : num13;
context.GetScreenSpaceTemporaryRT(command, down, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, num4, num5);
context.GetScreenSpaceTemporaryRT(command, up, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, num4, num5);
command.BlitFullscreenTriangle(source, down, propertySheet, pass);
source = down;
num4 = Mathf.Max(num4 / 2, 1);
num5 = Mathf.Max(num5 / 2, 1);
}
int num14 = m_Pyramid[num9 - 1].down;
for (int num15 = num9 - 2; num15 >= 0; num15--)
{
int down2 = m_Pyramid[num15].down;
int up2 = m_Pyramid[num15].up;
command.SetGlobalTexture(ShaderIDs.BloomTex, down2);
command.BlitFullscreenTriangle(num14, up2, propertySheet, 4 + num13);
num14 = up2;
}
Color linear = base.settings.color.value.linear;
float num16 = RuntimeUtilities.Exp2(base.settings.intensity.value / 10f) - 1f;
Vector4 value2 = new Vector4(num10, num16, base.settings.dirtIntensity.value, num9);
if (context.IsDebugOverlayEnabled(DebugOverlay.BloomThreshold))
{
context.PushDebugOverlay(command, context.source, propertySheet, 6);
}
else if (context.IsDebugOverlayEnabled(DebugOverlay.BloomBuffer))
{
propertySheet.properties.SetVector(ShaderIDs.ColorIntensity, new Vector4(linear.r, linear.g, linear.b, num16));
context.PushDebugOverlay(command, m_Pyramid[0].up, propertySheet, 7 + num13);
}
Texture texture = (!(base.settings.dirtTexture.value == null)) ? base.settings.dirtTexture.value : RuntimeUtilities.blackTexture;
float num17 = (float)texture.width / (float)texture.height;
float num18 = (float)context.screenWidth / (float)context.screenHeight;
Vector4 value3 = new Vector4(1f, 1f, 0f, 0f);
if (num17 > num18)
{
value3.x = num18 / num17;
value3.z = (1f - value3.x) * 0.5f;
}
else if (num18 > num17)
{
value3.y = num17 / num18;
value3.w = (1f - value3.y) * 0.5f;
}
PropertySheet uberSheet = context.uberSheet;
if ((bool)base.settings.fastMode)
{
uberSheet.EnableKeyword("BLOOM_LOW");
}
else
{
uberSheet.EnableKeyword("BLOOM");
}
uberSheet.properties.SetVector(ShaderIDs.Bloom_DirtTileOffset, value3);
uberSheet.properties.SetVector(ShaderIDs.Bloom_Settings, value2);
uberSheet.properties.SetColor(ShaderIDs.Bloom_Color, linear);
uberSheet.properties.SetTexture(ShaderIDs.Bloom_DirtTex, texture);
command.SetGlobalTexture(ShaderIDs.BloomTex, num14);
for (int j = 0; j < num9; j++)
{
if (m_Pyramid[j].down != num14)
{
command.ReleaseTemporaryRT(m_Pyramid[j].down);
}
if (m_Pyramid[j].up != num14)
{
command.ReleaseTemporaryRT(m_Pyramid[j].up);
}
}
command.EndSample("BloomPyramid");
context.bloomBufferNameID = num14;
}
public MockCSharpCompiler(string responseFile, string baseDirectory, string[] args)
: this(responseFile, baseDirectory, args, ImmutableArray <DiagnosticAnalyzer> .Empty, RuntimeUtilities.CreateAnalyzerAssemblyLoader())
{
}
static EntityConfigurationTypeFinder()
{
EntityRegistersDict = new Dictionary <Type, Dictionary <Type, EntityTypeConfigurationMetadata> >();
EntityMapDbContextDict = new Dictionary <Type, Type>();
Empty = new Dictionary <Type, EntityTypeConfigurationMetadata>();
DbContextTypes = new HashSet <Type>();
var assemblies = RuntimeUtilities.GetAllAssemblies();
var types = assemblies.SelectMany(assembly => assembly.DefinedTypes).Where(type =>
type.IsClass && !type.IsAbstract && !type.IsGenericTypeDefinition).ToArray();
var applyConfigurationMethod = typeof(ModelBuilder)
.GetMethods()
.Single(
e => e.Name == "ApplyConfiguration" &&
e.ContainsGenericParameters &&
e.GetParameters().SingleOrDefault()?.ParameterType.GetGenericTypeDefinition()
== typeof(IEntityTypeConfiguration <>));
foreach (var constructableType in types)
{
if (constructableType.GetConstructor(Type.EmptyTypes) == null)
{
continue;
}
object configuration = null;
foreach (var type in constructableType.GetInterfaces())
{
if (!type.IsGenericType)
{
continue;
}
// 只有指定了 DbContext 的接口才知道如何加载
// 没有指定 DbContext 的只能靠用户自己处理
if (type.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration <,>))
{
var entityType = type.GetGenericArguments()[0];
var dbContextType = type.GetGenericArguments()[1];
if (!EntityRegistersDict.ContainsKey(dbContextType))
{
EntityRegistersDict.Add(dbContextType,
new Dictionary <Type, EntityTypeConfigurationMetadata>());
}
configuration ??= Activator.CreateInstance(constructableType);
if (EntityRegistersDict[dbContextType].ContainsKey(entityType))
{
throw new MicroserviceFrameworkException($"类型 {entityType}, {dbContextType} 已经被注册过");
}
var methodInfo = applyConfigurationMethod.MakeGenericMethod(entityType);
EntityRegistersDict[dbContextType].Add(entityType,
new EntityTypeConfigurationMetadata(entityType, methodInfo, configuration));
EntityMapDbContextDict.AddOrUpdate(entityType, dbContextType);
DbContextTypes.Add(dbContextType);
}
// else if (type.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>))
// {
// var entityType = type.GetGenericArguments()[0];
// var dbContextType = typeof(DefaultDbContext);
// if (!EntityRegistersDict.ContainsKey(dbContextType))
// {
// EntityRegistersDict.Add(dbContextType, new List<object>());
// }
//
// EntityRegistersDict[dbContextType].Add(Activator.CreateInstance(constructableType));
//
// EntityMapDbContextDict.AddOrUpdate(entityType, dbContextType);
// }
}
}
}
void Destroy()
{
RuntimeUtilities.DestroyVolume(m_Volume, true);
}
public override void Release()
{
RuntimeUtilities.Destroy(m_InternalSpectralLut);
m_InternalSpectralLut = null;
}
void OnDisable()
{
profile = null;
RuntimeUtilities.DestroyVolume(m_Volume, false, true);
activeModifiers.Remove(this);
}
internal void Release()
{
RuntimeUtilities.Destroy(material);
material = null;
}
void OnDisable()
{
RuntimeUtilities.DestroyVolume(m_Volume, true, true);
}
SerializedProperty FindProperty <TValue>(Expression <Func <CinemachinePostProcessing, TValue> > expr)
{
return(serializedObject.FindProperty(RuntimeUtilities.GetFieldPath(expr)));
}
/// <summary>
/// Find a serialized property using an expression instead of a string. This is safer as it
/// helps avoiding typos and make code refactoring easier.
/// </summary>
/// <typeparam name="TValue">The serialized value type</typeparam>
/// <param name="expr">The expression to parse to reach the property</param>
/// <returns>A <see cref="SerializedProperty"/> or <c>null</c> if none was found</returns>
/// <example>
/// <code>
/// [Serializable]
/// public class MyEffect : PostProcessEffectSettings
/// {
/// public float myParameter = 1f;
/// }
///
/// [PostProcessEditor(typeof(MyEffect))]
/// public class MyEffectEditor : PostProcessEffectEditor<MyEffect>
/// {
/// SerializedProperty m_MyParameter;
///
/// public override void OnEnable()
/// {
/// m_MyParameter = FindProperty(x => x.myParameter);
/// }
/// }
/// </code>
/// </example>
/// <remarks>
/// If you're trying to retrieve a <see cref="SerializedParameterOverride"/>, you should
/// use <seealso cref="FindParameterOverride{TValue}"/> instead.
/// </remarks>
/// <seealso cref="SerializedProperty"/>
/// <seealso cref="FindParameterOverride{TValue}"/>
protected SerializedProperty FindProperty <TValue>(Expression <Func <T, TValue> > expr)
{
return(serializedObject.FindProperty(RuntimeUtilities.GetFieldPath(expr)));
}
public override void Release()
{
RuntimeUtilities.Destroy(accumText);
//Debug.Log("Destroying render texture");
}
private void OnDestroy()
{
StopAllCoroutines();
RuntimeUtilities.DestroyVolume(rippleVolume, true, true);
}
public void EndGameOverEffect()
{
RuntimeUtilities.DestroyVolume(_volume, false);
}
internal virtual void OnDisable()
{
RuntimeUtilities.Destroy(output);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.LabelField(EditorUtilities.GetContent("Volume blending"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
// The layout system sort of break alignement when mixing inspector fields with
// custom layouted fields, do the layout manually instead
var indentOffset = EditorGUI.indentLevel * 15f;
var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - 60f, lineRect.height);
var buttonRect = new Rect(fieldRect.xMax, lineRect.y, 60f, lineRect.height);
EditorGUI.PrefixLabel(labelRect, EditorUtilities.GetContent("Trigger|A transform that will act as a trigger for volume blending."));
m_VolumeTrigger.objectReferenceValue = (Transform)EditorGUI.ObjectField(fieldRect, m_VolumeTrigger.objectReferenceValue, typeof(Transform), false);
if (GUI.Button(buttonRect, EditorUtilities.GetContent("This|Assigns the current GameObject as a trigger."), EditorStyles.miniButton))
{
m_VolumeTrigger.objectReferenceValue = m_Target.transform;
}
if (m_VolumeTrigger.objectReferenceValue == null)
{
EditorGUILayout.HelpBox("No trigger has been set, the camera will only be affected by global volumes.", MessageType.Info);
}
EditorGUILayout.PropertyField(m_VolumeLayer, EditorUtilities.GetContent("Layer|This camera will only be affected by volumes in the selected scene-layers."));
int mask = m_VolumeLayer.intValue;
if (mask == 0)
{
EditorGUILayout.HelpBox("No layer has been set, the trigger will never be affected by volumes.", MessageType.Warning);
}
else if (mask == -1 || ((mask & 1) != 0))
{
EditorGUILayout.HelpBox("Do not use \"Everything\" or \"Default\" as a layer mask as it will slow down the volume blending process! Put post-processing volumes in their own dedicated layer for best performances.", MessageType.Warning);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField(EditorUtilities.GetContent("Anti-aliasing"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
m_AntialiasingMode.intValue = EditorGUILayout.Popup(EditorUtilities.GetContent("Mode|The anti-aliasing method to use. FXAA is fast but low quality. SMAA works well for non-HDR scenes. TAA is a bit slower but higher quality and works well with HDR."), m_AntialiasingMode.intValue, s_AntialiasingMethodNames);
if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.TemporalAntialiasing)
{
if (RuntimeUtilities.isSinglePassStereoEnabled)
{
EditorGUILayout.HelpBox("TAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
}
EditorGUILayout.PropertyField(m_TaaJitterSpread);
EditorGUILayout.PropertyField(m_TaaStationaryBlending);
EditorGUILayout.PropertyField(m_TaaMotionBlending);
EditorGUILayout.PropertyField(m_TaaSharpen);
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.SubpixelMorphologicalAntialiasing)
{
if (RuntimeUtilities.isSinglePassStereoEnabled)
{
EditorGUILayout.HelpBox("SMAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
}
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.FastApproximateAntialiasing)
{
EditorGUILayout.PropertyField(m_FxaaMobileOptimized);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField(EditorUtilities.GetContent("Debug Layer"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
EditorGUILayout.PropertyField(m_DebugDisplay, EditorUtilities.GetContent("Display|Toggle visibility of the debug layer on & off in the Game View."));
if (m_DebugDisplay.boolValue)
{
if (!SystemInfo.supportsComputeShaders)
{
EditorGUILayout.HelpBox("The debug layer only works on compute-shader enabled platforms.", MessageType.Info);
}
EditorGUILayout.PropertyField(m_DebugMonitor, EditorUtilities.GetContent("Monitor|The real-time monitor to display on the debug layer."));
EditorGUILayout.PropertyField(m_DebugLightMeter, EditorUtilities.GetContent("HDR Light Meter|Light metering utility used to setup auto exposure. Note that it will only display correct values when using a full-HDR workflow (HDR camera, HDR/Custom color grading)."));
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
// Toolkit
EditorUtilities.DrawSplitter();
GlobalSettings.showLayerToolkit = EditorUtilities.DrawHeader("Toolkit", GlobalSettings.showLayerToolkit);
if (GlobalSettings.showLayerToolkit)
{
EditorGUILayout.Space();
if (GUILayout.Button(EditorUtilities.GetContent("Export frame to EXR..."), EditorStyles.miniButton))
{
var menu = new GenericMenu();
menu.AddItem(EditorUtilities.GetContent("Full Frame (as displayed)"), false, () => ExportFrameToExr(ExportMode.FullFrame));
menu.AddItem(EditorUtilities.GetContent("Disable post-processing"), false, () => ExportFrameToExr(ExportMode.DisablePost));
menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Linear)"), false, () => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLinear));
menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Log)"), false, () => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLog));
menu.ShowAsContext();
}
if (GUILayout.Button(EditorUtilities.GetContent("Select all layer volumes|Selects all the volumes that will influence this layer."), EditorStyles.miniButton))
{
var volumes = RuntimeUtilities.GetAllSceneObjects <PostProcessVolume>()
.Where(x => (m_VolumeLayer.intValue & (1 << x.gameObject.layer)) != 0)
.Select(x => x.gameObject)
.Cast <UnityEngine.Object>()
.ToArray();
if (volumes.Length > 0)
{
Selection.objects = volumes;
}
}
if (GUILayout.Button(EditorUtilities.GetContent("Select all active volumes|Selects all volumes currently affecting the layer."), EditorStyles.miniButton))
{
var volumes = new List <PostProcessVolume>();
PostProcessManager.instance.GetActiveVolumes(m_Target, volumes);
if (volumes.Count > 0)
{
Selection.objects = volumes
.Select(x => x.gameObject)
.Cast <UnityEngine.Object>()
.ToArray();
}
}
EditorGUILayout.Space();
}
// Custom user effects sorter
EditorUtilities.DrawSplitter();
GlobalSettings.showCustomSorter = EditorUtilities.DrawHeader("Custom Effect Sorting", GlobalSettings.showCustomSorter);
if (GlobalSettings.showCustomSorter)
{
EditorGUILayout.Space();
bool anyList = false;
if (m_CustomLists != null)
{
foreach (var kvp in m_CustomLists)
{
var list = kvp.Value;
// Skip empty lists to avoid polluting the inspector
if (list.count == 0)
{
continue;
}
list.DoLayoutList();
anyList = true;
}
}
if (!anyList)
{
EditorGUILayout.HelpBox("No custom effect loaded.", MessageType.Info);
EditorGUILayout.Space();
}
}
EditorUtilities.DrawSplitter();
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
