internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
bool enabled = true;
D.assert(() => {
enabled = !D.debugDisableClipLayers;
return(true);
});
if (enabled)
{
builder.pushClipPath(this.clipPath.shift(layerOffset));
}
this.addChildrenToScene(builder, layerOffset);
if (enabled)
{
builder.pop();
}
return(null);
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
builder.pushBackdropFilter(this.filter);
this.addChildrenToScene(builder, layerOffset);
builder.pop();
return(null);
}
public Scene buildScene(SceneBuilder builder)
{
List <PictureLayer> temporaryLayers = null;
D.assert(() => {
if (RenderingDebugUtils.debugCheckElevationsEnabled)
{
temporaryLayers = this._debugCheckElevations();
}
return(true);
});
this.updateSubtreeNeedsAddToScene();
this.addToScene(builder);
Scene scene = builder.build();
D.assert(() => {
if (temporaryLayers != null)
{
foreach (PictureLayer temporaryLayer in temporaryLayers)
{
temporaryLayer.remove();
}
}
return(true);
});
return(scene);
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
D.assert(this.link != null);
if (this.link.leader == null && !this.showWhenUnlinked)
{
this._lastTransform = null;
this._lastOffset = null;
this._inverseDirty = true;
return(null);
}
this._establishTransform();
if (this._lastTransform != null)
{
builder.pushTransform(this._lastTransform.toMatrix3());
this.addChildrenToScene(builder);
builder.pop();
this._lastOffset = this.unlinkedOffset + layerOffset;
}
else
{
this._lastOffset = null;
var matrix = new Matrix4().translationValues(this.unlinkedOffset.dx, this.unlinkedOffset.dy, 0);
builder.pushTransform(matrix.toMatrix3());
this.addChildrenToScene(builder);
builder.pop();
}
this._inverseDirty = true;
return(null);
}
public ModelRoot Convert(PssgFile pssg)
{
var sceneBuilder = new SceneBuilder();
var state = CreateState();
// F1 games use lib YYY
var parent = pssg.FindNodes("LIBRARY", "type", "NODE").FirstOrDefault();
if (parent is null)
{
parent = pssg.FindNodes("LIBRARY", "type", "YYY").FirstOrDefault();
state.IsF1 = true;
}
if (parent is null)
{
throw new InvalidDataException("Could not find library with scene nodes.");
}
foreach (var child in parent.ChildNodes)
{
CreateNode(sceneBuilder, child, null, state);
}
return(sceneBuilder.ToGltf2());
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
D.assert(this.link != null);
if (this.link.leader == null && !this.showWhenUnlinked)
{
this._lastTransform = null;
this._lastOffset = null;
return(null);
}
this._establishTransform();
if (this._lastTransform != null)
{
builder.pushTransform(this._lastTransform);
this.addChildrenToScene(builder);
builder.pop();
this._lastOffset = this.unlinkedOffset + layerOffset;
}
else
{
this._lastOffset = null;
var matrix = Matrix3.makeTrans(this.unlinkedOffset.dx, this.unlinkedOffset.dy);
builder.pushTransform(matrix);
this.addChildrenToScene(builder);
builder.pop();
}
return(null);
}
public void Disposing_Scene_Releases_DrawOperation_References()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var bitmap = RefCountable.Create(Mock.Of <IBitmapImpl>());
Image img;
var tree = new TestRoot
{
Child = img = new Image
{
Source = new Bitmap(bitmap)
}
};
Assert.Equal(2, bitmap.RefCount);
IRef <IDrawOperation> operation;
using (var scene = new Scene(tree))
{
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
operation = scene.FindNode(img).DrawOperations[0];
Assert.Equal(1, operation.RefCount);
Assert.Equal(3, bitmap.RefCount);
}
Assert.Equal(0, operation.RefCount);
Assert.Equal(2, bitmap.RefCount);
}
}
public void Replacing_Control_Releases_DrawOperation_Reference()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var bitmap = RefCountable.Create(Mock.Of <IBitmapImpl>());
Image img;
var tree = new TestRoot
{
Child = img = new Image
{
Source = new Bitmap(bitmap)
}
};
var scene = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
var operation = scene.FindNode(img).DrawOperations[0];
tree.Child = new Decorator();
using (var result = scene.CloneScene())
{
sceneBuilder.Update(result, img);
scene.Dispose();
Assert.Equal(0, operation.RefCount);
Assert.Equal(2, bitmap.RefCount);
}
}
}
public void Setting_Opacity_Should_Add_Descendent_Bounds_To_DirtyRects()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Decorator decorator;
Border border;
var tree = new TestRoot
{
Child = decorator = new Decorator
{
Child = border = new Border
{
Background = Brushes.Red,
Width = 100,
Height = 100,
}
}
};
tree.Measure(Size.Infinity);
tree.Arrange(new Rect(tree.DesiredSize));
var scene = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
decorator.Opacity = 0.5;
scene = scene.CloneScene();
sceneBuilder.Update(scene, decorator);
Assert.NotEmpty(scene.Layers.Single().Dirty);
var dirty = scene.Layers.Single().Dirty.Single();
Assert.Equal(new Rect(0, 0, 100, 100), dirty);
}
}
public void ClipBounds_Should_Be_In_Global_Coordinates()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Border target;
var tree = new TestRoot
{
Child = new Decorator
{
Margin = new Thickness(24, 26),
Child = target = new Border
{
ClipToBounds = true,
Margin = new Thickness(26, 24),
Width = 100,
Height = 100,
}
}
};
tree.Measure(Size.Infinity);
tree.Arrange(new Rect(tree.DesiredSize));
var result = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(result);
var targetNode = result.FindNode(target);
Assert.Equal(new Rect(50, 50, 100, 100), targetNode.ClipBounds);
}
}
public void Should_Respect_ZIndex()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Border front;
Border back;
var tree = new TestRoot
{
Child = new Panel
{
Children =
{
(front = new Border
{
ZIndex = 1,
}),
(back = new Border
{
ZIndex = 0,
}),
}
}
};
var result = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(result);
var panelNode = result.FindNode(tree.Child);
var expected = new IVisual[] { back, front };
var actual = panelNode.Children.OfType <IVisualNode>().Select(x => x.Visual).ToArray();
Assert.Equal(expected, actual);
}
}
public void Control_With_Animated_Opacity_And_No_Children_Should_Not_Start_New_Layer()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Decorator decorator;
Border border;
var tree = new TestRoot
{
Padding = new Thickness(10),
Width = 100,
Height = 120,
Child = decorator = new Decorator
{
Padding = new Thickness(11),
Child = border = new Border
{
Background = Brushes.Red,
}
}
};
var layout = tree.LayoutManager;
layout.ExecuteInitialLayoutPass(tree);
var animation = new BehaviorSubject <double>(0.5);
border.Bind(Border.OpacityProperty, animation, BindingPriority.Animation);
var scene = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
Assert.Single(scene.Layers);
}
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
builder.addPerformanceOverlay(this.optionsMask, this.overlayRect.shift(layerOffset));
return(null);
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
builder.addPicture(layerOffset, this.picture,
isComplexHint: this.isComplexHint, willChangeHint: this.willChangeHint);
return(null);
}
protected override GameObject CreateGameObject(SceneBuilder builder, StaticMeshActor unrealNode)
{
var gameObject = CreateGameObjectImpl(builder, unrealNode.StaticMeshComponent.StaticMesh.FileName);
gameObject.name = unrealNode.ActorLabel;
return(gameObject);
}
public static GameObject CreateGameObjectImpl(SceneBuilder builder, string unrealMeshFile)
{
var gameObject = AssetDatabase.LoadAssetAtPath <GameObject>(Helper.GetMeshPath(unrealMeshFile));
gameObject = Object.Instantiate(gameObject);
return(gameObject);
}
public void Update()
{
// Skip Intro
if (Input.GetButtonUp("Cancel"))
{
SceneBuilder.LoadScene("MainMenu", "LoadScreen");
}
}
void Start()
{
WSU = gameObject.GetComponent <WorldStateUpdater>();
Debug.Log("World State Updater" + WSU);
teamNumber = WSU.thisTeamNumber;
scene = GameObject.FindWithTag("GameManager").GetComponent <SceneBuilder>();
spawner = scene.base2.GetComponent <Spawner>();
}
public void Should_Update_When_Control_Moved()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Decorator moveFrom;
Decorator moveTo;
Canvas moveMe;
var tree = new TestRoot
{
Width = 100,
Height = 100,
Child = new StackPanel
{
Children =
{
(moveFrom = new Decorator
{
Child = moveMe = new Canvas(),
}),
(moveTo = new Decorator()),
}
}
};
tree.Measure(Size.Infinity);
tree.Arrange(new Rect(tree.DesiredSize));
var scene = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
var moveFromNode = (VisualNode)scene.FindNode(moveFrom);
var moveToNode = (VisualNode)scene.FindNode(moveTo);
Assert.Equal(1, moveFromNode.Children.Count);
Assert.Same(moveMe, moveFromNode.Children[0].Visual);
Assert.Empty(moveToNode.Children);
moveFrom.Child = null;
moveTo.Child = moveMe;
scene = scene.CloneScene();
moveFromNode = (VisualNode)scene.FindNode(moveFrom);
moveToNode = (VisualNode)scene.FindNode(moveTo);
moveFromNode.SortChildren(scene);
moveToNode.SortChildren(scene);
sceneBuilder.Update(scene, moveFrom);
sceneBuilder.Update(scene, moveTo);
sceneBuilder.Update(scene, moveMe);
Assert.Empty(moveFromNode.Children);
Assert.Equal(1, moveToNode.Children.Count);
Assert.Same(moveMe, moveToNode.Children[0].Visual);
}
}
public void OnExportPropertiesHandler(SceneBuilder sceneBuilder, GameObject unityGameObject, Dictionary <string, object> propertyBag)
{
string stateMachineName = "Unknown";
if (!String.IsNullOrEmpty(this.stateMachineSource))
{
stateMachineName = this.stateMachineSource;
}
propertyBag.Add("stateMachineName", stateMachineName);
}
public void addChildrenToScene(SceneBuilder builder, Offset childOffset)
{
Layer child = this.firstChild;
while (child != null)
{
child.addToScene(builder, childOffset);
child = child.nextSibling;
}
}
void Start()
{
scene = GameObject.FindWithTag("GameManger").GetComponent <SceneBuilder>();
GameObject player2 = GameObject.FindWithTag("Player2");
player2ScriptAI = player2.GetComponent <PlayerGOAPAI>();
spawner = scene.base2.GetComponent <Spawner>();
WSU = player2.GetComponent <WorldStateUpdater>();
costToApply = scene.troopCosts[troopClass] - WSU.classCounts[(int)troopClass];
}
public void Init()
{
MissionBuilder = GameObject.Find("Scene").GetComponent <SceneBuilder>();
UI = GameObject.FindGameObjectWithTag("UI").GetComponent <SpaceUI>();
MissionRes = GameObject.Find("Scene").GetComponent <SceneRes>();
playership = MissionRes.playershiptransform.gameObject.GetComponent <Ship>();
RadioMessageObj = UI.RadioMessage;
InvokeRepeating("Step", 0, 1f);
}
void Awake()
{
Instance = this;
style_big = new GUIStyle2(360, Color.white);
style_normal = new GUIStyle2(49, Color.white);
if (floorObject && floorMaterial)
{
Renderer renderer = floorObject.GetComponent <Renderer>();
renderer.material.CopyPropertiesFromMaterial(floorMaterial);
}
}
public void Should_Update_Descendent_ClipBounds_When_Margin_Changed()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Border border;
Canvas canvas;
var tree = new TestRoot
{
Width = 200,
Height = 300,
Child = canvas = new Canvas
{
ClipToBounds = true,
Width = 100,
Height = 100,
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
Children =
{
(border = new Border
{
Background = Brushes.AliceBlue,
ClipToBounds = true,
Width = 100,
Height = 100,
[Canvas.LeftProperty] = 50,
[Canvas.TopProperty] = 50,
})
}
}
};
tree.Measure(Size.Infinity);
tree.Arrange(new Rect(tree.DesiredSize));
var scene = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(scene);
var borderNode = scene.FindNode(border);
Assert.Equal(new Rect(50, 50, 50, 50), borderNode.ClipBounds);
canvas.Width = canvas.Height = 125;
canvas.Measure(Size.Infinity);
canvas.Arrange(new Rect(tree.DesiredSize));
// Initial ClipBounds are correct, make sure they're still correct after updating canvas.
scene = scene.CloneScene();
Assert.True(sceneBuilder.Update(scene, canvas));
borderNode = scene.FindNode(border);
Assert.Equal(new Rect(50, 50, 75, 75), borderNode.ClipBounds);
}
}
internal void _addToSceneWithRetainedRendering(SceneBuilder builder)
{
if (!this._subtreeNeedsAddToScene && this._engineLayer != null)
{
builder.addRetained(this._engineLayer);
return;
}
this._engineLayer = this.addToScene(builder);
this._needsAddToScene = false;
}
public async Task Convert(MapDocument document, SceneBuilder builder, IEnumerable <IMapObject> affected, ResourceCollector resourceCollector)
{
var objs = document.Map.Root.FindAll();
if (affected != null)
{
var groups = affected.Select(x => x.ID / 200).ToHashSet();
foreach (var g in groups)
{
resourceCollector.RemoveRenderables(builder.GetRenderablesForGroup(g));
builder.DeleteGroup(g);
}
objs = objs.Where(x => groups.Contains(x.ID / 200)).ToList();
}
var converters = _converters.Select(x => x.Value).OrderBy(x => (int)x.Priority).ToList();
var groupConverters = _groupConverters.Select(x => x.Value).OrderBy(x => (int)x.Priority).ToList();
foreach (var g in objs.GroupBy(x => x.ID / 200))
{
builder.EnsureGroupExists(g.Key);
var buffer = builder.GetBufferForGroup(g.Key);
var collector = new ResourceCollector();
foreach (var gc in groupConverters)
{
gc.Convert(buffer, document, g, collector);
}
foreach (var obj in g)
{
foreach (var converter in converters)
{
if (!converter.Supports(obj))
{
continue;
}
await converter.Convert(buffer, document, obj, collector);
if (converter.ShouldStopProcessing(document, obj))
{
break;
}
}
}
builder.RemoveRenderablesFromGroup(g.Key, collector.GetRenderablesToRemove());
builder.AddRenderablesToGroup(g.Key, collector.GetRenderablesToAdd());
resourceCollector.Merge(collector);
}
builder.Complete();
}
public void Solution(int numTestCases, int numBombs, string htmlFileFullPath, string hyperspaceFileFullPath)
{
if (numTestCases < 1 || numTestCases > 10 || numBombs < 3 || numBombs > 50)
{
return;
}
exampleHtmlSceneBuilder = new SceneBuilder(htmlFileFullPath);
CreateNewHyperspace(numTestCases, numBombs, hyperspaceFileFullPath);
bool htmlFileMade = false;
foreach (var horrificSituation in ReadInputFile(hyperspaceFileFullPath))
{
//1 Make a kdtree
tree = new KdTree <int, int>(3, new IntMath());
foreach (var bomb in ParseTestCaseLine(horrificSituation))
{
tree.Add(bomb.Item1, bomb.Item2);
}
//2 balance the tree once all bombs/nodes have been added
tree.Balance();
//3. find the most remote bomb
var greatestNNDistance = 0;
var mostRemoteBomb = tree.First();
foreach (var node in tree)
{
var nodeNearestNeighbourDistance = SquaredDistanceToNearestNeighbour(node.Point);
if (nodeNearestNeighbourDistance > greatestNNDistance)
{
mostRemoteBomb = node;
greatestNNDistance = nodeNearestNeighbourDistance;
}
}
//4. Consider the hyperrects of the remotest bomb
var largestConnectedHyperrect = LargestConnectedHyperrect(mostRemoteBomb);
//Let's settle for the centre of this rectangle as the safest point.
var safestPoint = new int[] { (largestConnectedHyperrect.MaxPoint[0] + largestConnectedHyperrect.MinPoint[0]) / 2, (largestConnectedHyperrect.MaxPoint[1] + largestConnectedHyperrect.MinPoint[1]) / 2, (largestConnectedHyperrect.MaxPoint[2] + largestConnectedHyperrect.MinPoint[2]) / 2 };
if (!htmlFileMade)
{
exampleHtmlSceneBuilder.AddSafestPoint(safestPoint);
exampleHtmlSceneBuilder.Finish();
htmlFileMade = true;
}
//5 The requirements specicifically ask for the distance to the safest point's nearest neighbour.
var requiredDistanceValue = SquaredDistanceToNearestNeighbour(safestPoint);
}
}
public void Should_Update_Border_Background_Node()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
Border border;
TextBlock textBlock;
var tree = new TestRoot
{
Child = border = new Border
{
Width = 100,
Height = 100,
Background = Brushes.Red,
Child = textBlock = new TextBlock
{
Foreground = Brushes.Green,
Text = "Hello World",
}
}
};
tree.Measure(Size.Infinity);
tree.Arrange(new Rect(tree.DesiredSize));
var initial = new Scene(tree);
var sceneBuilder = new SceneBuilder();
sceneBuilder.UpdateAll(initial);
var initialBackgroundNode = initial.FindNode(border).Children[0];
var initialTextNode = initial.FindNode(textBlock).DrawOperations[0];
Assert.NotNull(initialBackgroundNode);
Assert.NotNull(initialTextNode);
border.Background = Brushes.Green;
var result = initial.CloneScene();
sceneBuilder.Update(result, border);
var borderNode = (VisualNode)result.Root.Children[0];
Assert.Same(border, borderNode.Visual);
var backgroundNode = (RectangleNode)borderNode.DrawOperations[0].Item;
Assert.NotSame(initialBackgroundNode, backgroundNode);
Assert.Equal(Brushes.Green, backgroundNode.Brush);
var textBlockNode = (VisualNode)borderNode.Children[0];
Assert.Same(textBlock, textBlockNode.Visual);
var textNode = (GlyphRunNode)textBlockNode.DrawOperations[0].Item;
Assert.Same(initialTextNode.Item, textNode);
}
}
internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null)
{
layerOffset = layerOffset ?? Offset.zero;
var engineLayer = builder.pushOffset(
(float)(layerOffset.dx + this.offset.dx),
(float)(layerOffset.dy + this.offset.dy));
this.addChildrenToScene(builder);
builder.pop();
return(engineLayer);
}
// Use this for initialization
void Start()
{
hexPlanet = planet.GetComponent<HexPlanet>();
planetBehavior = planet.GetComponent<PlanetBehavior>();
sceneBuilder = GameObject.FindGameObjectWithTag("GameController").GetComponent<SceneBuilder>();
}
public void OpenFrame(FrameDescription frame)
{
this.config.Merge(frame);
this.OutputSettings = new OutputSettingsInfo(frame);
this.QualitySettings = new QualitySettingsInfo(frame);
this.FrameName = frame.FrameName;
width = frame.Get<int>("ImageWidth");
height = frame.Get<int>("ImageHeight");
if (!string.IsNullOrWhiteSpace(frame.WorkingDir))
Directory.SetCurrentDirectory(frame.WorkingDir);
if (Scene == null) {
var svc = new SceneGraphService();
svc.Populate(new GlobalIndexObjLoader(), new MaterialLoader());
var builder = new SceneBuilder() { SGService = svc };
builder.Setup();
this.Scene = builder.OpenFrame(frame, AreaLightAsMeshLight);
this.Scene.DefaultLightGain = config.Get("LightGain", new RgbSpectrum(1.0f));
this.Scene.MaxPathDepth = config.Get("MaxPathDepth", 15);
this.Scene.RussianRuletteImportanceCap = config.Get("RRImportanceCap", 0.75f);
this.Scene.MaxPaths = config.Get("PathBufferSize", 65536 >> 10);
this.Scene.ShadowRayCount = config.Get("ShadowRayCount", 16);
this.Scene.TextureSamplingQuality = this.QualitySettings.TextureSamplingQuality;
this.Scene.AreaLightAsMesh = this.AreaLightAsMeshLight;
this.Scene.MatLib = new OptimizedBsdfLibrary();
this.Scene.MatLib.Populate(builder.MaterialInfos.ToArray());
(this.Scene.MatLib as OptimizedBsdfLibrary) .Replace("Object_MaterialView_Test", this.ObjectMaterial);
(this.Scene.MatLib as OptimizedBsdfLibrary).Replace("Plane_Material", this.PlaneMaterial);
foreach (var brdf in ObjectMaterial.Where(brdf => brdf != null))
{
builder.ProcessMaterial(0, brdf.MaterialData);
}
foreach (var brdf in PlaneMaterial.Where(brdf => brdf != null))
{
builder.ProcessMaterial(1, brdf.MaterialData);
}
RenderThreadsCount = config.Get("RenderThreadsCount",1);
this.scene = builder.SceneGeo;
var sceneBound = new AABB(scene.BoundingSphereCenter - scene.BoundingSphereRadius,
scene.BoundingSphereCenter + scene.BoundingSphereRadius);
sceneBound.Expand(1f);
//var viewBound = new AABB(Scene.Camera.Target - 5f, Scene.Camera.Target + 5f);
Scene.VolumeIntegrator = new SingleScatteringIntegrator(sceneBound, sceneBound.Size.Length / 10f, 0.15f, RgbSpectrum.UnitSpectrum()*0.095f, new RgbSpectrum(0.0005f));
}
this.Initialize();
}
public void LoadFrameDescription(FrameDescription frame)
{
this.Configuration.Merge(frame);
this.OutputSettings = new OutputSettingsInfo(frame);
this.QualitySettings = new QualitySettingsInfo(frame);
this.FrameName = frame.FrameName;
var width = frame.Get<int>("ImageWidth");
var height = frame.Get<int>("ImageHeight");
Directory.SetCurrentDirectory(frame.WorkingDir);
/*
foreach (var frameElement in frame.Elements.Where(frameElement => frameParsers.ContainsKey(frameElement.GetType()))) {
frameParsers[frameElement.GetType()](frameElement);
}*/
if (Scene == null)
{
SceneGraphService svc = new SceneGraphService();
svc.Populate(new GlobalIndexObjLoader(), new MaterialLoader());
//svc.OpenFrame(frame);
_builder = new SceneBuilder() { SGService = svc };
_builder.Setup();
this.Scene = _builder.OpenFrame(frame, AreaLightAsMeshLight);
this.Scene.DefaultLightGain = Configuration.Get("LightGain", new RgbSpectrum(1.0f));
this.Scene.MaxPathDepth = Configuration.Get("MaxPathDepth", 5);
this.Scene.RussianRuletteImportanceCap = Configuration.Get("RRImportanceCap", 0.75f);
this.Scene.MaxPaths = Configuration.Get("PathBufferSize", 65536 >> 10);
this.Scene.ShadowRayCount = Configuration.Get("ShadowRayCount", 1);
this.Scene.TextureSamplingQuality = this.QualitySettings.TextureSamplingQuality;
this.Scene.LightSamplingStrategy = LightSamplingStrategy.UniformOneLight;
var scene = _builder.SceneGeo;
var sceneBound = new AABB(scene.BoundingSphereCenter - scene.BoundingSphereRadius,
scene.BoundingSphereCenter + scene.BoundingSphereRadius);
sceneBound.Expand(1f);
//var viewBound = new AABB(Scene.Camera.Target - 5f, Scene.Camera.Target + 5f);
var c = new Point(Scene.Camera.Target);
var bb = new AABB(c - 1f, c + 1f);
var volumeBound = sceneBound;
Scene.VolumeIntegrator = new SingleScatteringIntegrator(volumeBound,
volumeBound.Size.Length / 10f, //step
0.005f, //Probability
RgbSpectrum.UnitSpectrum() * 0.095f, //Inscatering
new RgbSpectrum(0.00005f) //Emission
);
}
this.Context = new EngineContext() { RenderThreads = Configuration.Get("RenderThreadsCount", 1), FrameConfiguration = frame, Scene = this.Scene };
this.Initialize();
}
public virtual void Setup(IRayDenLibraryFrame newFrame)
{
var svc = new SceneGraphService();
svc.Populate(new GlobalIndexObjLoader(), new MaterialLoader());
sceneBuilder = new SceneBuilder() { SGService = svc };
sceneBuilder.Setup(this);
sceneBuilder.OpenFrame(newFrame);
}
public void OpenFrame(Library.Entity.Frames.FrameDescription frame)
{
this.CurrentFrame = new FrameConfiguration();
this.config.Merge(frame);
this.OutputSettings = new OutputSettingsInfo(frame);
this.QualitySettings = new QualitySettingsInfo(frame);
this.FrameName = frame.FrameName;
if (!string.IsNullOrWhiteSpace(frame.WorkingDir))
Directory.SetCurrentDirectory(frame.WorkingDir);
/*
foreach (var frameElement in frame.Elements.Where(frameElement => frameParsers.ContainsKey(frameElement.GetType()))) {
frameParsers[frameElement.GetType()](frameElement);
}*/
if (Scene == null)
{
SceneGraphService svc = new SceneGraphService();
svc.Populate(
//new ObjLoader(),
new GlobalIndexObjLoader(),
new MaterialLoader());
//svc.OpenFrame(frame);
_builder = new SceneBuilder() { SGService = svc };
_builder.Setup();
this.SceneGraph = _builder.SGService.SceneGraph;
this.Scene = _builder.OpenFrame(frame, this.AreaLightAsMeshLight);
this.Scene.DefaultLightGain = config.Get("LightGain", new RgbSpectrum(1.0f));
this.Scene.MaxPathDepth = config.Get("MaxPathDepth", 10);
this.Scene.RussianRuletteImportanceCap = config.Get("RRImportanceCap", 0.75f);
this.Scene.MaxPaths = config.Get("PathBufferSize", 65536);
this.Scene.ShadowRayCount = config.Get("ShadowRayCount", 1);
this.Scene.TextureSamplingQuality = this.QualitySettings.TextureSamplingQuality;
this.Scene.LightSamplingStrategy = this.QualitySettings.LightSamplingStrategy;
RgbSpectrum.Gamma = true;
/*
if (GlobalConfiguration.Instance.SpectralRendering)
{
this.Scene.SpectralMats = new BxDFLibrary(new LambertianBrdf(new[] { 0.5f, 0.5f, 0.5f }));
this.Scene.SpectralMats.Populate(_builder.MaterialInfos.ToArray());
}
else*/
{
this.Scene.MatLib = this.dependencyManager.GetMaterialPlugin(_builder.MaterialInfos.ToArray());
if (_builder.FrameMaterialBuilder != null)
{
this.Scene.MatLib.Add(_builder.FrameMaterialBuilder.Materials);
_builder.FrameMaterialBuilder.CreateRayEngineMaterials(this.Scene);
}
//if (EnableMaterialOverrides) FrameMaterialBuilder.ApplyMaterialOverrides((this.Scene.MatLib as OptimizedBsdfLibrary).Materials, Scene);
}
RenderThreadsCount = config.Get("RenderThreadsCount", 1);
this.scene = _builder.SceneGeo;
var sceneBound = new AABB(scene.BoundingSphereCenter - scene.BoundingSphereRadius,
scene.BoundingSphereCenter + scene.BoundingSphereRadius);
sceneBound.Expand(1f);
//var viewBound = new AABB(Scene.Camera.Target - 5f, Scene.Camera.Target + 5f);
var c = new Point(Scene.Camera.Target);
var bb = new AABB(c - 1f, c + 1f);
var volumeBound = sceneBound;
Scene.VolumeIntegrator = new SingleScatteringIntegrator(volumeBound,
volumeBound.Size.Length / 10f, //step
0.05f, //Probability
RgbSpectrum.UnitSpectrum() * 0.05f, //Inscatering
new RgbSpectrum(0.000f) //Emission
);
new RayEngineMaterialBuilder().BuildMaterials(this.Scene);
}
this.CurrentFrame.Width = frame.Get<int>("ImageWidth");
this.CurrentFrame.Height = frame.Get<int>("ImageHeight");
this.CurrentFrame.ImageSavePath = this.SavePath;
this.CurrentFrame.LowLatency = lowLatency;
this.CurrentFrame.MaxSamplesPerPixel = this.QualitySettings.SamplesPerPixel;
this.Initialize();
this.Scene.BuildPrimitives();
}
