//CAlled before activating new scene.
public void SceneLoaded()
{
//Reset has to be called before new scene calls awake methods,
//as sceneBehaviour might override profile.
PostProcessingManager.ResetProfile();
VRTK.VRTK_DeviceFinder.PlayAreaTransform().SetPositionAndRotation(Vector3.zero, Quaternion.identity);
}
void Start()
{
colliders = GetComponentsInChildren <BoxCollider>();
layers = GetComponentsInChildren <Layer>();
postProcessingManager = GetComponent <PostProcessingManager>();
mainCam = Camera.main;
}
public override void Enable(PostProcessingManager post, Camera camera = null)
{
postManager = post;
Init();
bloomDic[(int)BloomType.Elementary].Enable(post, camera);
bloomDic[(int)BloomType.Advanced].Enable(post, camera);
}
// Use this for initialization
void Start()
{
if (Instance == null)
{
DontDestroyOnLoad(this);
Instance = this;
}
}
void Start()
{
_controllerManager = GameManager.controllerManager;
_brightness = GameManager.brightness;
_postProcessingManager = GameManager.postProcessingManager;
CreateSupportedResolutionOptions();
SetIndexValues();
}
void Awake()
{
instance = this;
volume = gameObject.GetComponent <Volume>();
volume.profile.TryGet(out chromaticAberration);
volume.profile.TryGet(out lensDistortion);
volume.profile.TryGet(out motionBlur);
volume.profile.TryGet(out bloom);
}
internal static void Draw(PostProcessingSettings postProcessingSettings, PostProcessingManager postprocessingManager, FocusPuller focusPuller, bool showAdvanced)
{
GUILayout.BeginVertical(GUIStyles.Skin.box);
{
GUILayout.Label("Post Process Layer", GUIStyles.boldlabel);
GUILayout.Space(1);
if (showAdvanced)
{
GUILayout.Label("Volume blending", GUIStyles.boldlabel);
GUILayout.Space(1);
Label("Trigger", postProcessingSettings.VolumeTriggerSetting?.name);
Label("Layer", LayerMask.LayerToName(Mathf.RoundToInt(Mathf.Log(postProcessingSettings.VolumeLayerSetting.value, 2))));
GUILayout.Space(10);
}
GUILayout.Label("Anti-aliasing", GUIStyles.boldlabel);
Selection("Mode", postProcessingSettings.AntialiasingMode, mode => postProcessingSettings.AntialiasingMode = mode);
if (PostProcessingSettings.Antialiasing.SMAA == postProcessingSettings.AntialiasingMode)
{
Selection("SMAA Quality", postProcessingSettings.SMAAQuality, quality => postProcessingSettings.SMAAQuality = quality);
}
else if (PostProcessingSettings.Antialiasing.TAA == postProcessingSettings.AntialiasingMode)
{
Slider("Jitter Spread", postProcessingSettings.JitterSpread, 0.1f, 1f, "N2", spread => { postProcessingSettings.JitterSpread = spread; });
Slider("Stationary Blending", postProcessingSettings.StationaryBlending, 0f, 1f, "N2", sblending => { postProcessingSettings.StationaryBlending = sblending; });
Slider("Motion Blending", postProcessingSettings.MotionBlending, 0f, 1f, "N2", mblending => { postProcessingSettings.MotionBlending = mblending; });
Slider("Sharpness", postProcessingSettings.Sharpness, 0f, 3f, "N2", sharpness => { postProcessingSettings.Sharpness = sharpness; });
}
else if (PostProcessingSettings.Antialiasing.FXAA == postProcessingSettings.AntialiasingMode)
{
postProcessingSettings.FXAAMode = Toggle("Fast Mode", postProcessingSettings.FXAAMode);
postProcessingSettings.FXAAAlpha = Toggle("Keep Alpha", postProcessingSettings.FXAAAlpha);
}
}
GUILayout.EndVertical();
GUILayout.BeginVertical(GUIStyles.Skin.box);
{
string volumeLabel = "Post Process Volume";
if (showAdvanced)
{
volumeLabel = "Post Process Volumes";
}
GUILayout.Label(volumeLabel, GUIStyles.boldlabel);
postScrollView = GUILayout.BeginScrollView(postScrollView);
PostProcessVolumeSettings(postProcessingSettings, postprocessingManager, focusPuller, showAdvanced);
GUILayout.EndScrollView();
}
GUILayout.EndVertical();
}
/// <summary>
/// Called when graphics resources need to be loaded. Override this method to load any component-specific graphics resources.
/// </summary>
protected override void LoadContent()
{
camera = camera = new FirstPersonCamera(MathHelper.PiOver4, GraphicsDevice.PresentationParameters.BackBufferWidth / GraphicsDevice.PresentationParameters.BackBufferHeight, 1.0f, 500.0f);
camera.Position = new Vector3(0, 5, 10);
halfPixel.X = 0.5f / (float)GraphicsDevice.PresentationParameters.BackBufferWidth;
halfPixel.Y = 0.5f / (float)GraphicsDevice.PresentationParameters.BackBufferHeight;
// Get the sizes of the backbuffer, in order to have matching render targets
int backBufferWidth = GraphicsDevice.PresentationParameters.BackBufferWidth;
int backBufferHeight = GraphicsDevice.PresentationParameters.BackBufferHeight;
// Configure RenderTargets
//colorRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Color, DepthFormat.Depth24);
//normalRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Color, DepthFormat.None);
//depthRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Single, DepthFormat.None);
//depthTexture = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Single, DepthFormat.Depth24);
//lightRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Color, DepthFormat.None);
//sceneRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Color, DepthFormat.Depth24);
colorRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Rgba64, DepthFormat.Depth24);
normalRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Rgba64, DepthFormat.None);
depthRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Rgba64, DepthFormat.None);
depthTexture = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Color, DepthFormat.Depth24);
lightRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.HdrBlendable, DepthFormat.None);
sceneRT = new RenderTarget2D(GraphicsDevice, backBufferWidth, backBufferHeight, false, SurfaceFormat.Rgba64, DepthFormat.Depth24);
// Initialize SceneManager
scene.InitializeScene(camera);
// Instantiate the LightManager
lightManager = new LightManager(Game);
// Load Effects
clearBufferEffect = Game.Content.Load <Effect>("Shaders/GBuffer/ClearGBuffer");
finalCombineEffect = Game.Content.Load <Effect>("Shaders/GBuffer/CombineFinal");
depthShadowEffect = Game.Content.Load <Effect>("Shaders/Shadows/Depth");
sphereModel = Game.Content.Load <Model>("Models/sphere");
// Instantiate SpriteBatch
spriteBatch = new SpriteBatch(GraphicsDevice);
// Make our ShadowRenderer
shadowRenderer = new ShadowRenderer(GraphicsDevice, Game.Content);
// Instantiate the SSAO Renderer
ssaoRenderer = new SSAORenderer(Game, backBufferWidth, backBufferHeight);
// Instantiate the Sky Renderer
skyRenderer = new SkyRenderer(Game, camera);
// Instantiate the PostProcessing Manager
postProcessingManager = new PostProcessingManager(Game);
base.LoadContent();
}
private void Awake()
{
// if the singleton hasn't been initialized yet
if (instance != null && instance != this)
{
Destroy(this.gameObject);
}
instance = this;
DontDestroyOnLoad(this.gameObject);
}
private void SetSingleton()
{
if (Inst == null)
{
Inst = this;
}
else
{
Destroy(gameObject);
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
private void Awake()
{
if (instance != null)
{
Destroy(gameObject); //If the singleton already exists, do not instantiate this one
}
else
{
instance = this; //Initialize singleton variable
//DontDestroyOnLoad(gameObject);
}
}
public ImageViewer(Form1 a_Form, PostProcessingManager a_Manager)
: base(a_Form.Application)
{
this.D = a_Form.Device;
InitializeComponent();
this.Show(a_Form);
renderer = new ivRenderer(this);
a_Manager.AddPostProcessor(renderer);
CreateBackbuffer(false, pictureBox1);
this.FormClosing += new FormClosingEventHandler(ImageViewer_FormClosing);
xLoader = new XIMGLoader();
}
protected override void Initialize()
{
//NOTE: this is basic initialization of core components, nothing else
Screen.InitialSetup(_graphics, this, GraphicsDevice); // setup screen and create cameras
// init the post processing manager
PostProcessingManager.Initialize();
// Allow physics drawing for debug-reasons (display boundingboxes etc..)
// Todo: can be removed in the final stage of the game, but not yet, since it's extremly helpful to visualize the physics world
PhysicsDrawer.Initialize(this, GraphicsDevice);
base.Initialize();
}
/// <summary>
/// Used for initialization
/// </summary>
void Awake()
{
// if singleton has already initialized as another instance
if (instance != null && Instance != this)
{
// destroy this instance and break
Destroy(gameObject);
return;
}
// set this object as instance of singleton
instance = this;
DontDestroyOnLoad(gameObject);
}
void Awake()
{
PPManager = GetComponent <PostProcessingManager>();
#region OutlineSettingsInitialize
AA_None = PPManager.buttons.AA_None.GetComponent <Outline>();
AA_FXAA = PPManager.buttons.AA_FXAA.GetComponent <Outline>();
AA_SMAA = PPManager.buttons.AA_SMAA.GetComponent <Outline>();
Dit_OFF = PPManager.buttons.Dit_OFF.GetComponent <Outline>();
Dit_ON = PPManager.buttons.Dit_ON.GetComponent <Outline>();
Bl_OFF = PPManager.buttons.Bl_OFF.GetComponent <Outline>();
Bl_ON = PPManager.buttons.Bl_ON.GetComponent <Outline>();
CM_OFF = PPManager.buttons.CM_OFF.GetComponent <Outline>();
CM_ON = PPManager.buttons.CM_ON.GetComponent <Outline>();
ChA_OFF = PPManager.buttons.ChA_OFF.GetComponent <Outline>();
ChA_ON = PPManager.buttons.ChA_ON.GetComponent <Outline>();
CoA_OFF = PPManager.buttons.CoA_OFF.GetComponent <Outline>();
CoA_ON = PPManager.buttons.CoA_ON.GetComponent <Outline>();
CC_OFF = PPManager.buttons.CC_OFF.GetComponent <Outline>();
CC_ON = PPManager.buttons.CC_ON.GetComponent <Outline>();
CL_OFF = PPManager.buttons.CL_OFF.GetComponent <Outline>();
CL_ON = PPManager.buttons.CL_ON.GetComponent <Outline>();
DoF_OFF = PPManager.buttons.DoF_OFF.GetComponent <Outline>();
DoF_Gaussian = PPManager.buttons.DoF_Gaussian.GetComponent <Outline>();
DoF_Bokeh = PPManager.buttons.DoF_Bokeh.GetComponent <Outline>();
FG_OFF = PPManager.buttons.FG_OFF.GetComponent <Outline>();
FG_ON = PPManager.buttons.FG_ON.GetComponent <Outline>();
LD_OFF = PPManager.buttons.LD_OFF.GetComponent <Outline>();
LD_ON = PPManager.buttons.LD_ON.GetComponent <Outline>();
LGG_OFF = PPManager.buttons.LGG_OFF.GetComponent <Outline>();
LGG_ON = PPManager.buttons.LGG_ON.GetComponent <Outline>();
MB_OFF = PPManager.buttons.MB_OFF.GetComponent <Outline>();
MB_ON = PPManager.buttons.MB_ON.GetComponent <Outline>();
PP_OFF = PPManager.buttons.PP_OFF.GetComponent <Outline>();
PP_ON = PPManager.buttons.PP_ON.GetComponent <Outline>();
SMH_OFF = PPManager.buttons.SMH_OFF.GetComponent <Outline>();
SMH_ON = PPManager.buttons.SMH_ON.GetComponent <Outline>();
ST_OFF = PPManager.buttons.ST_OFF.GetComponent <Outline>();
ST_ON = PPManager.buttons.ST_ON.GetComponent <Outline>();
Ton_OFF = PPManager.buttons.Ton_OFF.GetComponent <Outline>();
Ton_None = PPManager.buttons.Ton_None.GetComponent <Outline>();
Ton_Neutral = PPManager.buttons.Ton_Neutral.GetComponent <Outline>();
Ton_ACES = PPManager.buttons.Ton_ACES.GetComponent <Outline>();
Vig_OFF = PPManager.buttons.Vig_OFF.GetComponent <Outline>();
Vig_ON = PPManager.buttons.Vig_ON.GetComponent <Outline>();
WB_OFF = PPManager.buttons.WB_OFF.GetComponent <Outline>();
WB_ON = PPManager.buttons.WB_ON.GetComponent <Outline>();
#endregion
InitializeButtonHighlights();
}
void OnEnable()
{
volume = GetComponent <PostProcessVolume>();
watersurface = FindObjectOfType <WaterSurface>();
ppm = FindObjectOfType <PostProcessingManager>();
bool foundEffectSettings = volume.profile.TryGetSettings <PreDeathEffect>(out predeatheffect);
if (!foundEffectSettings)
{
enabled = false;
Debug.Log("Cant load PreDeathEffect settings");
return;
}
}
public void Run()
{
using (var wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim = new Simulator(db.ConnectionString);
var calculationProfiler = new CalculationProfiler();
var csps = new CalcStartParameterSet(sim.GeographicLocations[0],
sim.TemperatureProfiles[0],
sim.ModularHouseholds[0],
EnergyIntensityType.EnergySaving,
false,
null,
LoadTypePriority.OptionalLoadtypes,
null,
null,
null,
new List <CalcOption>(),
new DateTime(2018, 1, 1),
new DateTime(2018, 1, 10),
new TimeSpan(0, 1, 0),
";",
1,
new TimeSpan(0, 1, 0),
false,
false,
false,
3,
3,
calculationProfiler, wd.WorkingDirectory, false);
var cmf = new CalcManagerFactory();
var cm = cmf.GetCalcManager(sim, csps, false);
cm.Run(null);
var mq = new Mock <ICalculationProfiler>();
wd.InputDataLogger.AddSaver(new ResultFileEntryLogger(wd.SqlResultLoggingService));
//FileFactoryAndTracker fft = new FileFactoryAndTracker(wd.WorkingDirectory,"objname",cm.Logfile.FileFactoryAndTracker);
//fft.RegisterHouseholdKey(Constants.GeneralHouseholdKey,"general");
//fft.RegisterHouseholdKey(Constants.GeneralHouseholdKey,"general");
var pcm = new PostProcessingManager(mq.Object, cm.CalcRepo.FileFactoryAndTracker);
//Debug.Assert(calcResult != null, nameof(calcResult) + " != null");
pcm.Run(wd.WorkingDirectory);
db.Cleanup();
}
wd.CleanUp();
}
}
private void Awake()
{
_puzzles = FindObjectsOfType <Puzzle>();
playerControlManager = GetComponent <PlayerControlManager>();
fpsController = FindObjectOfType <FirstPersonController>();
controllerManager = GetComponent <ControllerManager>();
brightness = FindObjectOfType <Brightness>();
postProcessingManager = GetComponent <PostProcessingManager>();
postProcessingBehaviour = FindObjectOfType <PostProcessingBehaviour>();
blackScreen = GameObject.Find("BlackFade");
power = GetComponent <Power>();
cursorManager = GetComponent <CursorManager>();
gameplayUIManager = FindObjectOfType <GameplayUIManager>();
videoSettingsManager = FindObjectOfType <VideoSettingsManager>();
loadingScreen = FindObjectOfType <LoadingScreen>();
audioSettingsManager = FindObjectOfType <AudioSettingsManager>();
controlSettingsManager = FindObjectOfType <ControlSettingsManager>();
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
graphics.GraphicsProfile = GraphicsProfile.HiDef;
Content.RootDirectory = "Content";
IsMouseVisible = true;
camera = new Base3DCamera(this, .1f, 2000f);
ppManager = new PostProcessingManager(this);
GodRays = new CrepuscularRays(this, sunPosition, "Textures/flare", 100, .99f, .99f, .5f, .12f, .25f);
ppManager.AddEffect(GodRays);
int sqr = 50;
//for (int a = 0; a < 100; a++)
//{
// float x = MathHelper.Lerp(-sqr, sqr, (float)rnd.NextDouble());
// float y = MathHelper.Lerp(-sqr, sqr, (float)rnd.NextDouble());
// float z = MathHelper.Lerp(-sqr, -sqr * 2, (float)rnd.NextDouble());
// float s = MathHelper.Lerp(.01f, 2, (float)rnd.NextDouble());
// //asteroids.Add(new Base3DModel(this, "Models/asteroid1", "Shaders/ColorDepthRender", "Textures/stone"));
// if (rnd.NextDouble() >= .5f)
// objects.Add(new Base3DModel(this, "Models/tank", "Shaders/ColorDepthRender"));
// else
// objects.Add(new Base3DModel(this, "Models/LandShark", "Shaders/ColorDepthRender"));
// objects[objects.Count - 1].Position = new Vector3(x, y, z);
// objects[objects.Count - 1].Scale = Vector3.One * s;
// Components.Add(objects[objects.Count - 1]);
// //asteroidsRotDir.Add(asteroidsRotDir.Count, Vector3.Normalize(asteroids[asteroids.Count - 1].Position));
//}
objects.Add(new Base3DModel(this, "Models/LandShark", "Shaders/ColorDepthRender"));
objects[0].Position = new Vector3(0, 0, -100);
objects[0].Scale = Vector3.One;
Components.Add(objects[0]);
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
IsMouseVisible = true;
//graphics.IsFullScreen = true;
//graphics.PreferredBackBufferHeight = 900;
//graphics.PreferredBackBufferWidth = 1440;
//graphics.PreferredBackBufferHeight = 900;
//graphics.PreferredBackBufferWidth = 1600;
graphics.PreferredBackBufferHeight = 600;
graphics.PreferredBackBufferWidth = 800;
ppm = new PostProcessingManager(this);
rays = new CrepuscularRays(this, Vector2.One * .5f, "Textures/flare", 1, .97f, .97f, .5f, .25f);
ppm.AddEffect(rays);
}
public virtual void Enable(PostProcessingManager post, Camera camera = null)
{
}
public void GragPost(int postId)
{
Stopwatch timer = new Stopwatch();
timer.Start();
// html = new HtmlWeb().Load(UrlConstants.SpecifiedPost + postId);
using (var client = new WebClient()) {
html.LoadHtml(client.DownloadString("http://pikabu.ru/" + UrlConstants.SpecifiedPost + postId));
}
//http://pikabu.ru/story/afrika_obedinyonnaya_respublika_tanzaniya_kakoyto_znakomyiy_vid_4820359#comment_81152709
// var restRequest = new RestRequest(UrlConstants.SpecifiedPost + postId, Method.GET);
//
// var restResponse = client.Execute(restRequest);
// var en = Encoding.GetEncoding("windows-1251");
// var ar = Encoding.Convert(Encoding.Default, en, Encoding.Default.GetBytes(restResponse.Content)).ToString();
// html.LoadHtml(ar);
var processingDateTime = DateTime.Now;
var post = html.DocumentNode.QuerySelector(".story");
if (post == null)
{
return;
}
var authorName = post.QuerySelector(".story__author").InnerText;
if (authorName == "ads")
{
return;
}
// empty link video url
// removed comment
using (var db = new DataContext()) {
// var user = PostProcessingManager.GetUser(db, authorName);
var postInfoNode = post.QuerySelector(".story__toggle-button");
Post dbPostEntry;
var postRate = post.QuerySelector(".story__rating-count");
var isDeleted = postRate.QuerySelectorAll("i.i-sprite--feed__rating-trash").Any(); //4801869 deleted
var rateNotAvailable = postRate.QuerySelectorAll("i").Any();
var postTitle = post.QuerySelector(".story__header-title a.story__title-link").InnerText;
var postContent = post.QuerySelector(".b-story__content")?.InnerHtml;
var postCreateDate = Helper.UnixTimeStampToDateTime(
double.Parse(
post.QuerySelector(".story__date").Attributes.AttributesWithName("title").FirstOrDefault().Value));
var commentsCount = Int32.Parse(post.QuerySelector(".story__comments-count").InnerText.Split(' ')[0]);
var postType = postInfoNode.Attributes.AttributesWithName("data-story-type").FirstOrDefault().Value;
var isLong = postInfoNode.Attributes.AttributesWithName("data-story-long").FirstOrDefault().Value.Equals("true", StringComparison.CurrentCultureIgnoreCase);
db.Posts.Add(dbPostEntry = new Post {
Id = postId,
Title = postTitle,
Content = postContent,
Created = postCreateDate,
LastCheck = processingDateTime,
CommentsCount = commentsCount,
IsDeleted = isDeleted,
Rating = rateNotAvailable ? (int?)null : int.Parse(postRate.InnerText),
AuthorName = authorName,
// Author = user,
Type = postType,
IsLong = isLong,
IsMine = post.QuerySelectorAll(".story__header-title a.story__authors").Any(),
IsStraw = post.QuerySelectorAll(".story__header-additional a.story__straw").Any(),
Tags = new List <PostTag>(),
PostLinks = new List <PostLink>(),
UserComments = new List <UserComment>()
});
foreach (var comment in html.DocumentNode.QuerySelectorAll(".b-comments_type_main .b-comment"))
{
CommentProcessing(comment, dbPostEntry);
}
if (dbPostEntry.CommentsCount > dbPostEntry.UserComments.Count)
{
AjaxUploadRestComments(dbPostEntry);
}
var postCommunity = post.QuerySelector(".story__author + a");
if (postCommunity != null)
{
var community = db.Communities.FirstOrDefault(x => x.Name == postCommunity.InnerText);
if (community == null)
{
db.Communities.Add(community = new Community {
Name = postCommunity.InnerText,
Link = postCommunity.GetAttributeValue("href", (string)null)
});
}
dbPostEntry.Community = community;
}
// var a = db.ChangeTracker.Entries().Where(e => e.State != System.Data.Entity.EntityState.Unchanged).ToList();
// var a2 = db.ChangeTracker.Entries().Where(e => e.State == System.Data.Entity.EntityState.Added).ToList();
// db.SaveChanges();
PostProcessingManager.ProcessingTags(db, dbPostEntry, post.QuerySelectorAll(".story__tag").Select(x => x.InnerText).ToList());
post.QuerySelectorAll("[data-large-image]")
.Select(x => x.ParentNode.GetAttributeValue("href", null)).ToList().ForEach((link) => {
dbPostEntry.PostLinks.Add(
new PostLink {
Url = link,
Type = LinkType.Image
});
});
post.QuerySelectorAll(".b-video")
.Select(x => {
var url = x.GetAttributeValue("data-url", null);
return(new PostLink {
Url = url,
DataId = //postType == "video" ?
url.Substring(url.LastIndexOf('/') + 1),
//VideoCodeRegex.Match(url).Value : x.GetAttributeValue("data-id", null),
Type = LinkType.Video
});
}).ToList().ForEach((link) => {
dbPostEntry.PostLinks.Add(link);
});
post.QuerySelectorAll(".b-gifx__player")
.Select(x =>
new PostLink {
Url = x.GetAttributeValue("data-src", null),
Type = LinkType.Gif
}
).ToList().ForEach((link) => {
dbPostEntry.PostLinks.Add(link);
});
post.QuerySelectorAll("noindex > a[rel=\"nofollow\"]")
.Select(x => x.GetAttributeValue("href", null)).ToList().ForEach(
(address) => {
var link = GetRefLinkByUrl <PostLink>(address);
dbPostEntry.PostLinks.Add(link);
});
// db.SaveChanges();
timer.Stop();
dbPostEntry.ProcessedTime = timer.Elapsed;
db.SaveChanges();
}
// for (int i = 0; i < 10; i++)
// Console.WriteLine(JsonConvert.SerializeObject(commentInfo[i]));
// IList<HtmlNode> nodes = html.QuerySelectorAll("div .my-class[data-attr=123] > ul li");
// HtmlNode node = nodes[0].QuerySelector("p.with-this-class span[data-myattr]");
// html.DocumentElement.SelectNodes("//a[@href")
// throw new NotImplementedException();
// });
// task.Wait();
// AltLog.Error($"{postId} #1 {altTimer.Elapsed}");
}
void Awake()
{
instance = this;
}
public override void Initialize()
{
ResourceManager.InitResourceManager();
GameLibrary.IO.IniFile inif = new GameLibrary.IO.IniFile("Resources/Settings.ini");
Camera.ReverseYAxis = bool.Parse(inif.IniReadValue("General", "ReverseMouseYAxis"));
string f = inif.IniReadValue("General", "RisenMainPath");
string s = null;
if (f != "" && f != "INVALID" && System.IO.Directory.Exists(f))
s = f;
FileManager.InitFileManager(this, s);
m_pRenderer = new ObjektRendererManager();
m_pPost = new PostProcessingManager();
m_pWindow = new Form1(this);
m_pPost.AddPostProcessor(new InformationDrawer(m_pWindow));
m_pPost.AddPostProcessor(new NodeDisplayerPostProc(m_pWindow));
m_pPost.AddPostProcessor(new GizmoComponent(m_pWindow));
m_pPost.AddPostProcessor(new IconDrawer(m_pWindow));
//Core.ObjektRendererManager.RegisterRenderer(new AmbientOutputRenderer(Core.Device));
//Core.ObjektRendererManager.GetPostProcessor<AmbientOutputRenderer>().Sorter = new Sorter();
m_pRenderer.RegisterRenderer(new ObjRenderer(m_pWindow));
m_pRenderer.RegisterRenderer(new GrassRendrer(m_pWindow));
m_pRenderer.RegisterRenderer(new NavRenderer(m_pWindow));
//base.Initialize();
m_pWindow.Show();
}
public override void Enable(PostProcessingManager post, Camera camera = null)
{
postManager = post;
Init();
camera.depthTextureMode |= DepthTextureMode.Depth;
}
public BaseDeferredRenderGame() : base()
{
graphics = new GraphicsDeviceManager(this);
graphics.PreparingDeviceSettings += new EventHandler <PreparingDeviceSettingsEventArgs>(graphics_PreparingDeviceSettings);
Content.RootDirectory = "Content";
inputHandler = new InputHandlerService(this);
assetManager = new AssetManager(this);
renderer = new DeferredRender(this);
rnd = new Random(DateTime.Now.Millisecond);
//ggr = new GeographicGridRegistrationSystem(this, new Vector3(10, 5, 20), new BoundingBox(-Vector3.One * 2f, Vector3.One * 2f));
ppManager = new PostProcessingManager(this);
test = new TesterEffect(this);
test.Enabled = false;
ppManager.AddEffect(test);
SSAO = new SSAOEffect(this, .1f, 1f, .5f, 1f);
SSAO.Enabled = false;
ppManager.AddEffect(SSAO);
//stHPe = new STHardPointEffect(this, 25, 30, new Color(48, 89, 122));
stHPe = new STHardPointEffect(this, 25, 30, new Color(41, 77, 107), new Color(.125f, .125f, .125f, 1.0f));
stHPe.Enabled = false;
ppManager.AddEffect(stHPe);
sun = new SunEffect(this, SunPosition);
sun.Enabled = false;
ppManager.AddEffect(sun);
water = new WaterEffect(this);
water.waterHeight = -25f;
water.Enabled = false;
ppManager.AddEffect(water);
dof = new DepthOfFieldEffect(this, 5, 30);
dof.Enabled = false;
ppManager.AddEffect(dof);
bloom = new BloomEffect(this, 1.25f, 1f, 1f, 1f, .25f, 4f);
bloom.Enabled = false;
ppManager.AddEffect(bloom);
haze = new HeatHazeEffect(this, "Textures/bumpmap", false);
haze.Enabled = false;
ppManager.AddEffect(haze);
radialBlur = new RadialBlurEffect(this, 0.009f);
radialBlur.Enabled = false;
ppManager.AddEffect(radialBlur);
ripple = new RippleEffect(this);
ripple.Enabled = false;
ppManager.AddEffect(ripple);
fog = new FogEffect(this, 50, 100, Color.DarkSlateGray);
fog.Enabled = false;
ppManager.AddEffect(fog);
godRays = new CrepuscularRays(this, SunPosition, "Textures/flare", 1500, 1f, .99f, 1f, .15f, .25f);
//godRays = new CrepuscularRays(this, SunPosition, "Textures/flare", 1500, 1f, .99f, .1f, 0.12f, .25f);
godRays.Enabled = false;
ppManager.AddEffect(godRays);
}
private static void PostProcessVolumeSettings(PostProcessingSettings settings, PostProcessingManager postprocessingManager, FocusPuller focusPuller, bool showAdvanced)
{
PostProcessVolume volume = settings.Volume;
GUILayout.Space(10);
Slider("Weight", volume.weight, 0f, 1f, "N1", weight => volume.weight = weight);
GUILayout.Space(10);
if (settings.ambientOcclusionLayer != null)
{
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.ambientOcclusionLayer.active =
settings.ambientOcclusionLayer.enabled.value = Toggle("Ambient Occlusion", settings.ambientOcclusionLayer.enabled.value, true);
if (settings.ambientOcclusionLayer.enabled.value)
{
Selection("Mode", settings.ambientOcclusionLayer.mode.value, mode => settings.ambientOcclusionLayer.mode.value = mode);
Slider("Intensity", settings.ambientOcclusionLayer.intensity.value, 0f, 4f, "N2",
intensity => settings.ambientOcclusionLayer.intensity.value = intensity, settings.ambientOcclusionLayer.intensity.overrideState,
overrideState => settings.ambientOcclusionLayer.intensity.overrideState = overrideState);
if (AmbientOcclusionMode.MultiScaleVolumetricObscurance == settings.ambientOcclusionLayer.mode.value)
{
Slider("Thickness Modifier", settings.ambientOcclusionLayer.thicknessModifier.value, 1f, 10f, "N2",
thickness => settings.ambientOcclusionLayer.thicknessModifier.value = thickness, settings.ambientOcclusionLayer.thicknessModifier.overrideState,
overrideState => settings.ambientOcclusionLayer.thicknessModifier.overrideState = overrideState);
}
else if (AmbientOcclusionMode.ScalableAmbientObscurance == settings.ambientOcclusionLayer.mode.value)
{
Slider("Radius", settings.ambientOcclusionLayer.radius.value, 1f, 10f, "N2",
radius => settings.ambientOcclusionLayer.radius.value = radius, settings.ambientOcclusionLayer.radius.overrideState,
overrideState => settings.ambientOcclusionLayer.radius.overrideState = overrideState);
}
SliderColor("Colour", settings.ambientOcclusionLayer.color.value,
colour => settings.ambientOcclusionLayer.color.value = colour, false, settings.ambientOcclusionLayer.color.overrideState,
overrideState => settings.ambientOcclusionLayer.color.overrideState = overrideState);
settings.ambientOcclusionLayer.ambientOnly.value = Toggle("Ambient Only", settings.ambientOcclusionLayer.ambientOnly.value);
}
GUILayout.EndVertical();
}
if (settings.AmplifyOcclusionComponent != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.AmplifyOcclusionComponent.enabled = Toggle("Amplify Ambient Occlusion", settings.AmplifyOcclusionComponent.enabled, true);
if (settings.AmplifyOcclusionComponent.enabled)
{
settings.AmplifyOcclusionComponent.CacheAware = Toggle("Cache Aware", settings.AmplifyOcclusionComponent.CacheAware);
settings.AmplifyOcclusionComponent.Downsample = Toggle("Downsample", settings.AmplifyOcclusionComponent.Downsample);
Selection("Apply Method", settings.AmplifyOcclusionComponent.ApplyMethod, mode => settings.AmplifyOcclusionComponent.ApplyMethod = mode);
Selection("PerPixel Normals", settings.AmplifyOcclusionComponent.PerPixelNormals, mode => settings.AmplifyOcclusionComponent.PerPixelNormals = mode);
Selection("Sample Count", settings.AmplifyOcclusionComponent.SampleCount, mode => settings.AmplifyOcclusionComponent.SampleCount = mode);
Slider("Bias", settings.AmplifyOcclusionComponent.Bias, 0f, 0.99f, "N2", bias => settings.AmplifyOcclusionComponent.Bias = bias);
Slider("Intensity", settings.AmplifyOcclusionComponent.Intensity, 0f, 4f, "N2", intensity => settings.AmplifyOcclusionComponent.Intensity = intensity);
Slider("Power Exponent", settings.AmplifyOcclusionComponent.PowerExponent, 0f, 16f, "N2", powerExponent => settings.AmplifyOcclusionComponent.PowerExponent = powerExponent);
Slider("Radius", settings.AmplifyOcclusionComponent.Radius, 0f, 32f, "N2", radius => settings.AmplifyOcclusionComponent.Radius = radius);
Slider("Thickness", settings.AmplifyOcclusionComponent.Thickness, 0f, 1f, "N2", thickness => settings.AmplifyOcclusionComponent.Thickness = thickness);
SliderColor("Tint", settings.AmplifyOcclusionComponent.Tint, colour => settings.AmplifyOcclusionComponent.Tint = colour);
settings.AmplifyOcclusionComponent.BlurEnabled = Toggle("Blur Enabled", settings.AmplifyOcclusionComponent.BlurEnabled);
if (settings.AmplifyOcclusionComponent.BlurEnabled)
{
Slider("Blur Sharpness", settings.AmplifyOcclusionComponent.BlurSharpness, 0f, 20f, "N2", blurSharpness => settings.AmplifyOcclusionComponent.BlurSharpness = blurSharpness);
Slider("Blur Passes", settings.AmplifyOcclusionComponent.BlurPasses, 1, 4, blurPasses => settings.AmplifyOcclusionComponent.BlurPasses = blurPasses);
Slider("Blur Radius", settings.AmplifyOcclusionComponent.BlurRadius, 1, 4, blurRadius => settings.AmplifyOcclusionComponent.BlurRadius = blurRadius);
}
settings.AmplifyOcclusionComponent.FilterEnabled = Toggle("Filter Enabled", settings.AmplifyOcclusionComponent.FilterEnabled);
if (settings.amplifyOcclusionComponent.FilterEnabled)
{
Slider("Filter Blending", settings.AmplifyOcclusionComponent.FilterBlending, 0f, 1f, "N2", filterBlending => settings.AmplifyOcclusionComponent.FilterBlending = filterBlending);
Slider("Filter Response", settings.AmplifyOcclusionComponent.FilterResponse, 0f, 1f, "N2", filterResponse => settings.AmplifyOcclusionComponent.FilterResponse = filterResponse);
}
settings.AmplifyOcclusionComponent.FadeEnabled = Toggle("Fade Enabled", settings.AmplifyOcclusionComponent.FadeEnabled);
if (settings.AmplifyOcclusionComponent.FadeEnabled)
{
Slider("Fade Length", settings.AmplifyOcclusionComponent.FadeLength, 0f, 100f, "N2", fadeLength => settings.AmplifyOcclusionComponent.FadeLength = fadeLength);
Slider("Fade Start", settings.AmplifyOcclusionComponent.FadeStart, 0f, 100f, "N2", fadeStart => settings.AmplifyOcclusionComponent.FadeStart = fadeStart);
Slider("Fade To Intensity", settings.AmplifyOcclusionComponent.FadeToIntensity, 0f, 1f, "N2", fadeToIntensity => settings.AmplifyOcclusionComponent.FadeToIntensity = fadeToIntensity);
Slider("Fade To Power Exponent", settings.AmplifyOcclusionComponent.FadeToPowerExponent, 0f, 16f, "N2", fadeToPowerExponent => settings.AmplifyOcclusionComponent.FadeToPowerExponent = fadeToPowerExponent);
Slider("Fade To Radius", settings.AmplifyOcclusionComponent.FadeToRadius, 0f, 32f, "N2", fadeToRadius => settings.AmplifyOcclusionComponent.FadeToRadius = fadeToRadius);
Slider("Fade To Thickness", settings.AmplifyOcclusionComponent.FadeToThickness, 0f, 1f, "N2", fadeToThickness => settings.AmplifyOcclusionComponent.FadeToThickness = fadeToThickness);
SliderColor("Fade To Tint", settings.AmplifyOcclusionComponent.FadeToTint, colour => settings.AmplifyOcclusionComponent.FadeToTint = colour);
}
}
GUILayout.EndVertical();
}
if (settings.autoExposureLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.autoExposureLayer.active =
settings.autoExposureLayer.enabled.value = Toggle("Auto Exposure", settings.autoExposureLayer.enabled.value, true);
if (settings.autoExposureLayer.enabled.value)
{
settings.autoExposureLayer.filtering.overrideState = Toggle("Histogram Filtering (%)", settings.autoExposureLayer.filtering.overrideState);
Vector2 filteringRange = settings.autoExposureLayer.filtering.value;
Slider("Lower Bound", filteringRange.x, 1f, Math.Min(filteringRange.y, 99f), "N0", filtering => filteringRange.x = filtering, settings.autoExposureLayer.filtering.overrideState);
Slider("Upper Bound", filteringRange.y, Math.Max(filteringRange.x, 1f), 99f, "N0", filtering => filteringRange.y = filtering, settings.autoExposureLayer.filtering.overrideState);
settings.autoExposureLayer.filtering.value = filteringRange;
Slider("Min Luminance (EV)", settings.autoExposureLayer.minLuminance.value, -9f, 9f, "N0",
luminance => settings.autoExposureLayer.minLuminance.value = luminance, settings.autoExposureLayer.minLuminance.overrideState,
overrideState => settings.autoExposureLayer.minLuminance.overrideState = overrideState);
Slider("Max Luminance (EV)", settings.autoExposureLayer.maxLuminance.value, -9f, 9f, "N0",
luminance => settings.autoExposureLayer.maxLuminance.value = luminance, settings.autoExposureLayer.maxLuminance.overrideState,
overrideState => settings.autoExposureLayer.maxLuminance.overrideState = overrideState);
GUILayout.Space(5);
settings.autoExposureLayer.eyeAdaptation.overrideState = Toggle("Eye Adaptation", settings.autoExposureLayer.eyeAdaptation.overrideState);
Selection("Type", settings.autoExposureLayer.eyeAdaptation.value, type => settings.autoExposureLayer.eyeAdaptation.value = type, -1,
settings.autoExposureLayer.eyeAdaptation.overrideState);
Slider("Speed from light to dark", settings.autoExposureLayer.speedUp.value, 0f, 10f, "N1",
luminance => settings.autoExposureLayer.speedUp.value = luminance, settings.autoExposureLayer.speedUp.overrideState,
overrideState => settings.autoExposureLayer.speedUp.overrideState = overrideState);
Slider("Speed from dark to light", settings.autoExposureLayer.speedDown.value, 0f, 10f, "N1",
luminance => settings.autoExposureLayer.speedDown.value = luminance, settings.autoExposureLayer.speedDown.overrideState,
overrideState => settings.autoExposureLayer.speedDown.overrideState = overrideState);
}
GUILayout.EndVertical();
}
if (settings.bloomLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.bloomLayer.active =
settings.bloomLayer.enabled.value = Toggle("Bloom", settings.bloomLayer.enabled.value, true);
if (settings.bloomLayer.enabled.value)
{
Slider("Intensity", settings.bloomLayer.intensity.value, 0f, 10f, "N1", intensity => settings.bloomLayer.intensity.value = intensity,
settings.bloomLayer.intensity.overrideState, overrideState => settings.bloomLayer.intensity.overrideState = overrideState);
Slider("Threshold", settings.bloomLayer.threshold.value, 0f, 10f, "N1", threshold => settings.bloomLayer.threshold.value = threshold,
settings.bloomLayer.threshold.overrideState, overrideState => settings.bloomLayer.threshold.overrideState = overrideState);
Slider("SoftKnee", settings.bloomLayer.softKnee.value, 0f, 1f, "N1", softKnee => settings.bloomLayer.softKnee.value = softKnee,
settings.bloomLayer.softKnee.overrideState, overrideState => settings.bloomLayer.softKnee.overrideState = overrideState);
Slider("Clamp", settings.bloomLayer.clamp.value, 0, 65472, "N0", clamp => settings.bloomLayer.clamp.value = clamp,
settings.bloomLayer.clamp.overrideState, overrideState => settings.bloomLayer.clamp.overrideState = overrideState);
Slider("Diffusion", (int)settings.bloomLayer.diffusion.value, 1, 10, "N0", diffusion => settings.bloomLayer.diffusion.value = diffusion,
settings.bloomLayer.diffusion.overrideState, overrideState => settings.bloomLayer.diffusion.overrideState = overrideState);
Slider("AnamorphicRatio", settings.bloomLayer.anamorphicRatio.value, -1, 1, "N1", anamorphicRatio => settings.bloomLayer.anamorphicRatio.value = anamorphicRatio,
settings.bloomLayer.anamorphicRatio.overrideState, overrideState => settings.bloomLayer.anamorphicRatio.overrideState = overrideState);
SliderColor("Colour", settings.bloomLayer.color.value, colour => { settings.bloomLayer.color.value = colour; }, settings.bloomLayer.color.overrideState,
settings.bloomLayer.color.overrideState, overrideState => settings.bloomLayer.color.overrideState = overrideState);
settings.bloomLayer.fastMode.value = Toggle("Fast Mode", settings.bloomLayer.fastMode.value);
int lensDirtIndex = SelectionTexture("Lens Dirt", postprocessingManager.CurrentLensDirtTextureIndex, postprocessingManager.LensDirtPreviews, Inspector.Width / 100,
settings.bloomLayer.dirtTexture.overrideState, overrideState => settings.bloomLayer.dirtTexture.overrideState = overrideState, GUIStyles.Skin.box);
if (-1 != lensDirtIndex && lensDirtIndex != postprocessingManager.CurrentLensDirtTextureIndex)
{
postprocessingManager.LoadLensDirtTexture(lensDirtIndex, dirtTexture => settings.bloomLayer.dirtTexture.value = dirtTexture);
}
settings.bloomLayer.dirtIntensity.value = Text("Dirt Intensity", settings.bloomLayer.dirtIntensity.value, "N2",
settings.bloomLayer.dirtIntensity.overrideState, overrideState => settings.bloomLayer.dirtIntensity.overrideState = overrideState);
}
GUILayout.EndVertical();
}
if (settings.chromaticAberrationLayer)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.chromaticAberrationLayer.active =
settings.chromaticAberrationLayer.enabled.value = Toggle("Chromatic Aberration", settings.chromaticAberrationLayer.enabled.value, true);
if (settings.chromaticAberrationLayer.enabled.value)
{
Slider("Intensity", settings.chromaticAberrationLayer.intensity.value, 0f, 5f, "N3", intensity => settings.chromaticAberrationLayer.intensity.value = intensity,
settings.chromaticAberrationLayer.intensity.overrideState, overrideState => settings.chromaticAberrationLayer.intensity.overrideState = overrideState);
settings.chromaticAberrationLayer.fastMode.value = Toggle("Fast Mode", settings.chromaticAberrationLayer.fastMode.value);
}
GUILayout.EndVertical();
}
if (settings.colorGradingLayer)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.colorGradingLayer.active =
settings.colorGradingLayer.enabled.value = Toggle("Colour Grading", settings.colorGradingLayer.enabled.value, true);
if (settings.colorGradingLayer.enabled.value)
{
Selection("Mode", (PostProcessingSettings.GradingMode)settings.colorGradingLayer.gradingMode.value, mode => settings.colorGradingLayer.gradingMode.value = (UnityEngine.Rendering.PostProcessing.GradingMode)mode);
if (GradingMode.External != settings.colorGradingLayer.gradingMode.value)
{
if (GradingMode.LowDefinitionRange == settings.colorGradingLayer.gradingMode.value)
{
Selection("LUT", postprocessingManager.CurrentLUTName, postprocessingManager.LUTNames,
lut => { if (lut != postprocessingManager.CurrentLUTName)
{
settings.colorGradingLayer.ldrLut.value = postprocessingManager.LoadLUT(lut);
}
}, Inspector.Width / 150,
settings.colorGradingLayer.ldrLut.overrideState, overrideState => settings.colorGradingLayer.ldrLut.overrideState = overrideState);
Slider("LUT Blend", settings.colorGradingLayer.ldrLutContribution.value, 0, 1, "N3", ldrLutContribution => settings.colorGradingLayer.ldrLutContribution.value = ldrLutContribution,
settings.colorGradingLayer.ldrLutContribution.overrideState, overrideState => settings.colorGradingLayer.ldrLutContribution.overrideState = overrideState);
}
else
{
Selection("Tonemapping", settings.colorGradingLayer.tonemapper.value, mode => settings.colorGradingLayer.tonemapper.value = mode);
}
GUILayout.Space(1);
GUILayout.Label("White Balance");
Slider("Temperature", settings.colorGradingLayer.temperature.value, -100, 100, "N1", temperature => settings.colorGradingLayer.temperature.value = temperature,
settings.colorGradingLayer.temperature.overrideState, overrideState => settings.colorGradingLayer.temperature.overrideState = overrideState);
Slider("Tint", settings.colorGradingLayer.tint.value, -100, 100, "N1", tint => settings.colorGradingLayer.tint.value = tint,
settings.colorGradingLayer.tint.overrideState, overrideState => settings.colorGradingLayer.tint.overrideState = overrideState);
GUILayout.Space(1);
GUILayout.Label("Tone");
if (GradingMode.HighDefinitionRange == settings.colorGradingLayer.gradingMode.value)
{
settings.colorGradingLayer.postExposure.value = Text("Post-exposure (EV)", settings.colorGradingLayer.postExposure.value, "N2",
settings.colorGradingLayer.postExposure.overrideState, overrideState => settings.colorGradingLayer.postExposure.overrideState = overrideState);
}
Slider("Hue Shift", settings.colorGradingLayer.hueShift.value, -180, 180, "N1", hueShift => settings.colorGradingLayer.hueShift.value = hueShift,
settings.colorGradingLayer.hueShift.overrideState, overrideState => settings.colorGradingLayer.hueShift.overrideState = overrideState);
Slider("Saturation", settings.colorGradingLayer.saturation.value, -100, 100, "N1", saturation => settings.colorGradingLayer.saturation.value = saturation,
settings.colorGradingLayer.saturation.overrideState, overrideState => settings.colorGradingLayer.saturation.overrideState = overrideState);
if (GradingMode.LowDefinitionRange == settings.colorGradingLayer.gradingMode.value)
{
Slider("Brightness", settings.colorGradingLayer.brightness.value, -100, 100, "N1", brightness => settings.colorGradingLayer.brightness.value = brightness,
settings.colorGradingLayer.brightness.overrideState, overrideState => settings.colorGradingLayer.brightness.overrideState = overrideState);
}
Slider("Contrast", settings.colorGradingLayer.contrast.value, -100, 100, "N1", contrast => settings.colorGradingLayer.contrast.value = contrast,
settings.colorGradingLayer.contrast.overrideState, overrideState => settings.colorGradingLayer.contrast.overrideState = overrideState);
SliderColor("Lift", settings.colorGradingLayer.lift.value, colour => settings.colorGradingLayer.lift.value = colour, false,
settings.colorGradingLayer.lift.overrideState, overrideState => settings.colorGradingLayer.lift.overrideState = overrideState);
SliderColor("Gamma", settings.colorGradingLayer.gamma.value, colour => settings.colorGradingLayer.gamma.value = colour, false,
settings.colorGradingLayer.gamma.overrideState, overrideSate => settings.colorGradingLayer.gamma.overrideState = overrideSate);
SliderColor("Gain", settings.colorGradingLayer.gain.value, colour => settings.colorGradingLayer.gain.value = colour, false,
settings.colorGradingLayer.gain.overrideState, overrideSate => settings.colorGradingLayer.gain.overrideState = overrideSate);
}
else
{
GUILayout.Label("Not supported at present");
}
}
GUILayout.EndVertical();
}
if (settings.depthOfFieldLayer)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.depthOfFieldLayer.active =
settings.depthOfFieldLayer.enabled.value = Toggle("Depth Of Field", settings.depthOfFieldLayer.enabled.value, true);
if (settings.depthOfFieldLayer.enabled.value)
{
focusPuller.enabled = Toggle("Auto Focus", focusPuller.enabled);
Slider("Focal Distance", settings.depthOfFieldLayer.focusDistance.value, 0.1f, 20f, "N2", focusDistance => settings.depthOfFieldLayer.focusDistance.value = focusDistance,
settings.depthOfFieldLayer.focusDistance.overrideState && !focusPuller.enabled, overrideState => settings.depthOfFieldLayer.focusDistance.overrideState = overrideState);
Slider("Aperture", settings.depthOfFieldLayer.aperture.value, 1f, 22f, "N1", aperture => settings.depthOfFieldLayer.aperture.value = aperture,
settings.depthOfFieldLayer.aperture.overrideState, overrideState => settings.depthOfFieldLayer.aperture.overrideState = overrideState);
Slider("Focal Length", settings.depthOfFieldLayer.focalLength.value, 10f, 600f, "N0", focalLength => settings.depthOfFieldLayer.focalLength.value = focalLength,
settings.depthOfFieldLayer.focalLength.overrideState, overrideState => settings.depthOfFieldLayer.focalLength.overrideState = overrideState);
Selection("Max Blur Size", settings.depthOfFieldLayer.kernelSize.value, kernelSize => settings.depthOfFieldLayer.kernelSize.value = kernelSize, -1,
settings.depthOfFieldLayer.kernelSize.overrideState, overrideState => settings.depthOfFieldLayer.kernelSize.overrideState = overrideState);
}
GUILayout.EndVertical();
}
if (settings.grainLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.grainLayer.active =
settings.grainLayer.enabled.value = Toggle("Grain", settings.grainLayer.enabled.value, true);
if (settings.grainLayer.enabled.value)
{
settings.grainLayer.colored.overrideState = Toggle("Colored", settings.grainLayer.colored.overrideState);
Slider("Intensity", settings.grainLayer.intensity.value, 0f, 20f, "N2", intensity => settings.grainLayer.intensity.value = intensity,
settings.grainLayer.intensity.overrideState, overrideState => settings.grainLayer.intensity.overrideState = overrideState);
Slider("Size", settings.grainLayer.size.value, 0f, 10f, "N0", focalLength => settings.grainLayer.size.value = focalLength,
settings.grainLayer.size.overrideState, overrideState => settings.grainLayer.size.overrideState = overrideState);
Slider("Luminance Contribution", settings.grainLayer.lumContrib.value, 0f, 22f, "N1", lumContrib => settings.grainLayer.lumContrib.value = lumContrib,
settings.grainLayer.lumContrib.overrideState, overrideState => settings.grainLayer.lumContrib.overrideState = overrideState);
}
GUILayout.EndVertical();
}
if (settings.screenSpaceReflectionsLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.screenSpaceReflectionsLayer.active =
settings.screenSpaceReflectionsLayer.enabled.value = Toggle("Screen Space Reflection", settings.screenSpaceReflectionsLayer.enabled.value, true);
if (settings.screenSpaceReflectionsLayer.enabled.value)
{
Selection("Preset", settings.screenSpaceReflectionsLayer.preset.value, preset => settings.screenSpaceReflectionsLayer.preset.value = preset, -1,
settings.screenSpaceReflectionsLayer.preset.overrideState, overrideState => settings.screenSpaceReflectionsLayer.preset.overrideState = overrideState);
Text("Maximum March Distance", settings.screenSpaceReflectionsLayer.maximumMarchDistance.value, "N2",
settings.screenSpaceReflectionsLayer.maximumMarchDistance.overrideState, overrideState => settings.screenSpaceReflectionsLayer.maximumMarchDistance.overrideState = overrideState);
Slider("Distance Fade", settings.screenSpaceReflectionsLayer.distanceFade, 0f, 1f, "N3", fade => settings.screenSpaceReflectionsLayer.distanceFade.value = fade,
settings.screenSpaceReflectionsLayer.distanceFade.overrideState, overrideState => settings.screenSpaceReflectionsLayer.distanceFade.overrideState = overrideState);
Slider("Vignette", settings.screenSpaceReflectionsLayer.vignette.value, 0f, 1f, "N3", vignette => settings.screenSpaceReflectionsLayer.vignette.value = vignette,
settings.screenSpaceReflectionsLayer.vignette.overrideState, overrideState => settings.screenSpaceReflectionsLayer.vignette.overrideState = overrideState);
}
GUILayout.EndVertical();
}
if (settings.vignetteLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.vignetteLayer.active =
settings.vignetteLayer.enabled.value = Toggle("Vignette", settings.vignetteLayer.enabled.value, true);
if (settings.vignetteLayer.enabled.value)
{
Selection("Mode", settings.vignetteLayer.mode.value, mode => settings.vignetteLayer.mode.value = mode, -1,
settings.vignetteLayer.mode.overrideState, overrideState => settings.vignetteLayer.mode.overrideState = overrideState);
SliderColor("Color", settings.vignetteLayer.color.value, colour => settings.vignetteLayer.color.value = colour, false,
settings.vignetteLayer.color.overrideState, overrideState => settings.vignetteLayer.color.overrideState = overrideState);
Slider("Intensity", settings.vignetteLayer.intensity, 0f, 1f, "N3", fade => settings.vignetteLayer.intensity.value = fade,
settings.vignetteLayer.intensity.overrideState, overrideState => settings.vignetteLayer.intensity.overrideState = overrideState);
Slider("Smoothness", settings.vignetteLayer.smoothness.value, 0.01f, 1f, "N3", vignette => settings.vignetteLayer.smoothness.value = vignette,
settings.vignetteLayer.smoothness.overrideState, overrideState => settings.vignetteLayer.smoothness.overrideState = overrideState);
Slider("Roundness", settings.vignetteLayer.roundness.value, 0f, 1f, "N3", vignette => settings.vignetteLayer.roundness.value = vignette,
settings.vignetteLayer.roundness.overrideState, overrideState => settings.vignetteLayer.roundness.overrideState = overrideState);
settings.vignetteLayer.rounded.value = Toggle("Rounded", settings.vignetteLayer.rounded, settings.vignetteLayer.rounded.overrideState);
}
GUILayout.EndVertical();
}
if (settings.motionBlurLayer != null)
{
GUILayout.Space(1);
GUILayout.BeginVertical(GUIStyles.Skin.box);
settings.motionBlurLayer.active =
settings.motionBlurLayer.enabled.value = Toggle("Motion Blur", settings.motionBlurLayer.enabled.value, true);
if (settings.motionBlurLayer.enabled.value)
{
Slider("Shutter Angle", settings.motionBlurLayer.shutterAngle.value, 0f, 360f, "N2", intensity => settings.motionBlurLayer.shutterAngle.value = intensity,
settings.motionBlurLayer.shutterAngle.overrideState, overrideState => settings.motionBlurLayer.shutterAngle.overrideState = overrideState);
Slider("Sample Count", settings.motionBlurLayer.sampleCount.value, 4, 32, intensity => settings.motionBlurLayer.sampleCount.value = intensity,
settings.motionBlurLayer.sampleCount.overrideState, overrideState => settings.motionBlurLayer.sampleCount.overrideState = overrideState);
}
GUILayout.EndVertical();
}
}
public CalcParameters MakeCalculationParametersFromConfig([NotNull] CalcStartParameterSet csps, bool forceRandom)
{
CalcParameters cp = CalcParameters.GetNew();
cp.LoadtypesToPostprocess = csps.LoadTypesToProcess;
cp.SetDeleteDatFiles(csps.DeleteDatFiles);
cp.SetWriteExcelColumn (csps.WriteExcelColumn);
cp.SetManyOptionsWithClear(csps.CalcOptions);
FileFactoryAndTrackerDummy fftd = new FileFactoryAndTrackerDummy();
var container =PostProcessingManager.RegisterEverything(csps.ResultPath,csps.CalculationProfiler, fftd);
using (var scope = container.BeginLifetimeScope())
{
var odm = scope.Resolve<OptionDependencyManager>();
odm.EnableRequiredOptions(cp.Options);
}
cp.SetShowSettlingPeriod(csps.ShowSettlingPeriod);
cp.SetRandomSeed(csps.SelectedRandomSeed, forceRandom);
cp.SetCsvCharacter(csps.CsvCharacter);
cp.SetStartDate(csps.OfficialSimulationStartTime);
cp.SetEndDate(csps.OfficialSimulationEndTime.AddDays(1));
cp.SetInternalTimeResolution(csps.InternalTimeResolution);
cp.SetExternalTimeResolution(csps.ExternalTimeResolution);
cp.SetLoadTypePriority(csps.LoadTypePriority);
cp.SetSettlingDays(csps.SettlingDays);
cp.SetAffordanceRepetitionCount(csps.AffordanceRepetitionCount);
cp.DeviceProfileHeaderMode = csps.DeviceProfileHeaderMode;
cp.IgnorePreviousActivitesWhenNeeded = csps.IgnorePreviousActivitiesWhenNeeded;
cp.TransportationEnabled = csps.TransportationEnabled;
if (cp.TransportationEnabled && csps.CalcTarget.CalcObjectType == CalcObjectType.House) {
if (csps.ChargingStationSet != null) {
throw new LPGException("trying to set transportation options on a house. that won't work.");
}
if (csps.TransportationDeviceSet != null)
{
throw new LPGException("trying to set transportation options on a house. that won't work.");
}
if (csps.TravelRouteSet != null)
{
throw new LPGException("trying to set transportation options on a house. that won't work.");
}
}
if (cp.TransportationEnabled && csps.CalcTarget.CalcObjectType == CalcObjectType.ModularHousehold)
{
if (csps.ChargingStationSet == null)
{
throw new LPGException("Trying to set transportation options on a household without charging station set. That won't work.");
}
if (csps.TransportationDeviceSet == null)
{
throw new LPGException("Trying to set transportation options on a household without transportation device set. That won't work.");
}
if (csps.TravelRouteSet != null)
{
throw new LPGException("trying to set transportation options on a house. that won't work.");
}
}
cp.CheckSettings();
//transport mode
/*if (csps.TransportationDeviceSet != null || csps.TravelRouteSet != null) {
cp.SetTransportMode(true);
if (csps.TransportationDeviceSet == null ) {
throw new DataIntegrityException("Only a transportation device set was defined, but not a travel route set. This can't work.");
}
if (csps.TravelRouteSet == null)
{
throw new DataIntegrityException("Only a travel route set was defined, but not a transportation device set. This can't work.");
}
}*/
return cp;
}
public override void Enable(PostProcessingManager post, Camera camera = null)
{
postManager = post;
}
// ReSharper disable once CollectionNeverUpdated.Local
public static void CheckForResultfile(string wd, CalcOption option)
{
var srls = new SqlResultLoggingService(wd);
var rfel = new ResultFileEntryLogger(srls);
var rfes = rfel.Load();
var foundOptions = new List <CalcOption>();
//collect all the file keys
foreach (var rfe in rfes)
{
if (!File.Exists(rfe.FullFileName))
{
throw new LPGException("File " + rfe.FullFileName +
" was registered, but is not actually present.");
}
foundOptions.Add(rfe.EnablingCalcOption);
}
// ReSharper disable once CollectionNeverQueried.Local
var allTables = new List <ResultTableDefinition>();
var hhKeyLogger = new HouseholdKeyLogger(srls);
var keys = hhKeyLogger.Load();
foreach (var key in keys)
{
if (!srls.FilenameByHouseholdKey.ContainsKey(key.HHKey))
{
continue;
}
var fn = srls.FilenameByHouseholdKey[key.HHKey];
if (!File.Exists(fn.Filename))
{
continue;
}
var tables = srls.LoadTables(key.HHKey);
allTables.AddRange(tables);
foreach (var table in tables)
{
foundOptions.Add(table.EnablingOption);
}
}
foundOptions = foundOptions.Distinct().ToList();
var optionsThatDontResultInFiles = new List <CalcOption>();
optionsThatDontResultInFiles.Add(CalcOption.MakePDF);
optionsThatDontResultInFiles.Add(CalcOption.ActionCarpetPlot);
optionsThatDontResultInFiles.Add(CalcOption.HouseholdPlan);
optionsThatDontResultInFiles.Add(CalcOption.CalculationFlameChart);
optionsThatDontResultInFiles.Add(CalcOption.MakeGraphics);
optionsThatDontResultInFiles.Add(CalcOption.LogErrorMessages);
optionsThatDontResultInFiles.Add(CalcOption.EnergyCarpetPlot);
optionsThatDontResultInFiles.Add(CalcOption.DurationCurve);
optionsThatDontResultInFiles.Add(CalcOption.TransportationDeviceCarpetPlot);
optionsThatDontResultInFiles.Add(CalcOption.LocationCarpetPlot);
if (!optionsThatDontResultInFiles.Contains(option))
{
if (!foundOptions.Contains(option))
{
throw new LPGException("Option found that doesn't result in any files");
}
}
var fftd = new FileFactoryAndTrackerDummy();
var cp = new CalculationProfiler();
var container = PostProcessingManager.RegisterEverything(wd, cp, fftd);
var enabledOptions = new HashSet <CalcOption>();
enabledOptions.Add(option);
using (var scope = container.BeginLifetimeScope()) {
var odm = scope.Resolve <OptionDependencyManager>();
odm.EnableRequiredOptions(enabledOptions);
}
foreach (var enabledOption in enabledOptions)
{
foundOptions.Remove(enabledOption);
}
if (foundOptions.Contains(CalcOption.BasicOverview))
{
foundOptions.Remove(CalcOption.BasicOverview);
}
if (foundOptions.Count > 0)
{
var s = string.Join("\n", foundOptions.Select(x => x.ToString()));
throw new LPGException("found stuff that was not requested:" + s);
}
var filesthatdontneedtoregister = new List <string>();
filesthatdontneedtoregister.Add("finished.flag");
filesthatdontneedtoregister.Add("log.commandlinecalculation.txt");
filesthatdontneedtoregister.Add("results.general.sqlite");
filesthatdontneedtoregister.Add("results.general.sqlite-wal");
filesthatdontneedtoregister.Add("results.general.sqlite-shm");
filesthatdontneedtoregister.Add("results.hh1.sqlite");
filesthatdontneedtoregister.Add("results.hh1.sqlite-shm");
filesthatdontneedtoregister.Add("results.hh1.sqlite-wal");
filesthatdontneedtoregister.Add("results.house.sqlite");
filesthatdontneedtoregister.Add("results.house.sqlite-shm");
filesthatdontneedtoregister.Add("results.house.sqlite-wal");
filesthatdontneedtoregister.Add("calculationprofiler.json");
//check if all files are registered
var di = new DirectoryInfo(wd);
var files = di.GetFiles("*.*", SearchOption.AllDirectories);
var registeredFiles = rfes.Select(x => x.FullFileName).ToList();
foreach (var file in files)
{
if (filesthatdontneedtoregister.Contains(file.Name.ToLower(CultureInfo.InvariantCulture)))
{
continue;
}
if (!registeredFiles.Contains(file.FullName))
{
throw new LPGException("Found unregistered file: " + file.FullName);
}
}
//foundKeys = foundKeys.Distinct().ToList();
//if (_resultFileIdsByCalcOption.ContainsKey(option)) {
// var rl = _resultFileIdsByCalcOption[option];
// foreach (var key in rl.ResultKeys) {
// if (!foundKeys.Contains(key)) {
// throw new LPGException("in the found keys the file " + key + " is missing.");
// }
// }
// foreach (var key in foundKeys) {
// if (!rl.ResultKeys.Contains(key)) {
// throw new LPGException("in the result list keys the file " + key + " is missing.");
// }
// }
//}
//else {
// //todo: this needs to be done differently. need to disable as much as possible except the given calc option first.
// var sb = new StringBuilder();
// sb.Append("--------------");
// sb.AppendLine();
// sb.Append("_resultFileIdsByCalcOption.Add(CalcOption." + option + ", ResultList.Make(CalcOption.");
// sb.Append(option).Append(", ");
// foreach (var key in foundKeys) {
// sb.AppendLine();
// sb.Append("\"").Append(key).Append("\", ");
// }
// sb.Remove(sb.Length - 2, 2);
// sb.Append("));");
// sb.AppendLine();
// sb.Append("--------------");
// Logger.Info(sb.ToString());
// //throw new LPGException(sb.ToString());
//}
}
public UserConsole(Form1 F, PostProcessingManager a_Manager)
{
D = F.Device;
drawer = new ConsolProcessor(F, this);
a_Manager.AddPostProcessor(drawer);
m_Strings = new List<string>();
currLine = string.Empty;
}
// Start is called before the first frame update
void Reset()
{
postProcessingManager = GetComponent <PostProcessingManager>();
}
public override void LoadContent()
{
if (content == null)
content = ScreenManager.Game.Content;
sky = content.Load<Texture2D>("sky_bg");
ppm = new PostProcessingManager(ScreenManager.Game);
rays = new CrepuscularRays(ScreenManager.Game, Vector2.One * .5f, "flare4", 0.35f, .87f, .97f, .3f, .20f);
ppm.AddEffect(rays);
ScreenManager.Game.Services.AddService(ScreenManager.SpriteBatch.GetType(), ScreenManager.SpriteBatch);
UpdateLightSource();
scene = new RenderTarget2D(ScreenManager.Game.GraphicsDevice,
ScreenManager.Game.GraphicsDevice.Viewport.Width,
ScreenManager.Game.GraphicsDevice.Viewport.Height,
false,
SurfaceFormat.Color,
DepthFormat.None);
AddBackground("cloud1", 0.5f);
AddBackground("midground_grasshill", 0.0f);
}
