public void AddCamera()
{
const string yaml = @"
- add: camera
width: 100
height: 100
field-of-view: 0.785
from: [ -6, 6, -10 ]
to: [ 6, 0, 6 ]
up: [ -0.45, 1, 0 ]";
var parser = new YamlParser();
var(_, camera) = parser.LoadYaml(yaml);
var transform = ViewTransform.Create(
new Point(-6, 6, -10),
new Point(6, 0, 6),
new Vector(-0.45f, 1, 0));
Assert.Equal(100, camera.Width);
Assert.Equal(100, camera.Height);
Assert.Equal(0.785f, camera.FieldOfView);
Assert.Equal(transform, camera.Transform);
}
private bool SetTileMatrix()
{
var tileMatrixZoomLevel = (int)Math.Floor(ParentMap.ZoomLevel + 0.001); // avoid rounding issues
var tileMatrixScale = ViewTransform.ZoomLevelToScale(tileMatrixZoomLevel);
// bounds in tile pixels from view size
//
var bounds = ParentMap.ViewTransform.GetTileMatrixBounds(tileMatrixScale, MapTopLeft, ParentMap.RenderSize);
// tile column and row index bounds
//
var xMin = (int)Math.Floor(bounds.X / TileSize);
var yMin = (int)Math.Floor(bounds.Y / TileSize);
var xMax = (int)Math.Floor((bounds.X + bounds.Width) / TileSize);
var yMax = (int)Math.Floor((bounds.Y + bounds.Height) / TileSize);
if (TileMatrix != null &&
TileMatrix.ZoomLevel == tileMatrixZoomLevel &&
TileMatrix.XMin == xMin && TileMatrix.YMin == yMin &&
TileMatrix.XMax == xMax && TileMatrix.YMax == yMax)
{
return(false);
}
TileMatrix = new TileMatrix(tileMatrixZoomLevel, xMin, yMin, xMax, yMax);
return(true);
}
protected override void LoadContent()
{
base.LoadContent();
Rt = new RenderTarget2D(Graphics.GraphicsDevice, 512, 512);
var provider = new EmbeddedFreeTypeFontProvider(RenderCoordinator);
Font = provider.Load("FiraSans-Medium");
Font.SizePoints = 20;
Font.GlyphMargin = 4;
Texture = Texture2D.FromStream(Graphics.GraphicsDevice, Assembly.GetExecutingAssembly().GetManifestResourceStream("bunny"));
try {
Materials = new DefaultMaterialSet(RenderCoordinator)
{
ViewTransform = ViewTransform.CreateOrthographic(Graphics.PreferredBackBufferWidth, Graphics.PreferredBackBufferHeight)
};
} catch (Exception exc) {
Console.WriteLine("Shader load failed.");
Console.WriteLine(exc);
Thread.Sleep(5000);
Environment.Exit(1);
return;
}
EffectProvider = new EmbeddedEffectProvider(RenderCoordinator);
Vpos = new Material(EffectProvider.Load("vpos"), "vposShader");
Materials.Add(Vpos);
}
public void CreateDefaultOrientation()
{
var from = new Point(0, 0, 0);
var to = new Point(0, 0, -1);
var up = new Vector(0, 1, 0);
Assert.Equal(Matrix4x4.Identity(), ViewTransform.Create(from, to, up));
}
protected override void AnimateView(float animationDelta)
{
var transformPosition = ViewTransform.position;
var amountToShakeX = transformPosition.x + Mathf.Sin(Time.time * animationDelta) * 1f;
var shakeFromPosition = new Vector3(amountToShakeX, transformPosition.y);
ViewTransform.Translate(shakeFromPosition);
}
private static void _ApplyLocalTransformMatrix(ref ViewTransform vt, object _control)
{
var control = (Control)_control;
control.Appearance.GetPlacementTransformMatrix(
control.MostRecentCompositeData.Box, control.Context.NowL, out Matrix transform
);
vt.ModelView *= transform;
}
public void ViewTransform()
{
Tuple from = Tuple.Point(1, 3, 2);
Tuple to = Tuple.Point(4, -2, 8);
Tuple up = Tuple.Vector(1, 1, 0);
Matrix t = new ViewTransform(from, to, up).GetTransform();
Assert.AreEqual(t, new Matrix(-0.50709, 0.50709, 0.67612, -2.36643, 0.76772, 0.60609, 0.12122, -2.82843, -0.35857, 0.59761, -0.71714, 0.00000, 0.00000, 0.00000, 0.00000, 1.00000));
}
public void ViewTransformMovesWorld()
{
Tuple from = Tuple.Point(0, 0, 8);
Tuple to = Tuple.Point(0, 0, 0);
Tuple up = Tuple.Vector(0, 1, 0);
Matrix t = new ViewTransform(from, to, up).GetTransform();
Assert.AreEqual(t, new Translate(0, 0, -8).GetTransform());
}
public void ViewTransformPZ()
{
Tuple from = Tuple.Point(0, 0, 0);
Tuple to = Tuple.Point(0, 0, 1);
Tuple up = Tuple.Vector(0, 1, 0);
Matrix t = new ViewTransform(from, to, up).GetTransform();
Assert.AreEqual(t, new Scale(-1, 1, -1).GetTransform());
}
public void DefaultView()
{
Tuple from = Tuple.Point(0, 0, 0);
Tuple to = Tuple.Point(0, 0, -1);
Tuple up = Tuple.Vector(0, 1, 0);
Matrix t = new ViewTransform(from, to, up).GetTransform();
Assert.AreEqual(t, Matrix.GetIdentityMatrix());
}
/// <summary>
/// put the blockview under the CodingContent, not in the menu, or child of other block views
/// </summary>
public void SetOrphan()
{
if (InToolbox)
{
InToolbox = false;
}
ViewTransform.SetParent(BlocklyUI.WorkspaceView.CodingArea);
ViewTransform.SetAsLastSibling();
}
public void CreateTranslation()
{
var from = new Point(0, 0, 8);
var to = new Point(0, 0, 0);
var up = new Vector(0, 1, 0);
var expected = Matrix4x4.Translation(0, 0, -8);
var actual = ViewTransform.Create(from, to, up);
Assert.Equal(expected, actual);
}
protected override void SetRenderTransform()
{
// tile matrix origin in pixels
//
var tileMatrixOrigin = new Point(TileSize * TileMatrix.XMin, TileSize * TileMatrix.YMin);
var tileMatrixScale = ViewTransform.ZoomLevelToScale(TileMatrix.ZoomLevel);
((MatrixTransform)RenderTransform).Matrix =
ParentMap.ViewTransform.GetTileLayerTransform(tileMatrixScale, MapTopLeft, tileMatrixOrigin);
}
public void CreateScaling()
{
var from = new Point(0, 0, 0);
var to = new Point(0, 0, 1);
var up = new Vector(0, 1, 0);
var expected = Matrix4x4.Scaling(-1, 1, -1);
var actual = ViewTransform.Create(from, to, up);
Assert.Equal(expected, actual);
}
private void RegisterUIEvents()
{
//show mutator editor
var mutatorEntry = ViewTransform.Find("Mutator_entry");
if (mutatorEntry != null)
{
mutatorEntry.GetComponent <Button>().onClick.AddListener(() =>
DialogFactory.CreateMutatorDialog(mBlock)
);
}
}
public void RenderDefaultWorld()
{
var from = new Point(0, 0, -5);
var to = new Point(0, 0, 0);
var up = new Vector(0, 1, 0);
var transform = ViewTransform.Create(from, to, up);
var camera = new Camera(11, 11, MathF.PI / 2, transform);
var world = new DefaultWorld();
var canvas = world.Render(camera);
Assert.Equal(new Color(0.38066f, 0.47583f, 0.2855f), canvas[5, 5]);
}
private Camera ParseCamera(YamlNode node)
{
var width = 0;
var height = 0;
float fieldOfView = 0;
var from = Point.Zero;
var to = Point.Zero;
var up = Vector.UnitY;
foreach (var child in (YamlMappingNode)node)
{
var key = ((YamlScalarNode)child.Key).Value.ToUpperInvariant();
switch (key)
{
case "WIDTH":
width = ParseInt(child.Value);
break;
case "HEIGHT":
height = ParseInt(child.Value);
break;
case "FIELD-OF-VIEW":
fieldOfView = ParseFloat(child.Value);
break;
case "FROM":
from = ParsePoint(child.Value);
break;
case "TO":
to = ParsePoint(child.Value);
break;
case "UP":
up = ParseVector(child.Value);
break;
case "ADD": break;
default:
throw new Exception($"Camera attribute {key} not supported (line {child.Key.Start.Line})");
}
}
var cameraTransform = ViewTransform.Create(from, to, up);
return(new Camera(width, height, fieldOfView, cameraTransform));
}
private void AddNewObject(ushort id, ViewTransform newTransform)
{
var newObject = gameContext.CreateEntity();
newObject.AddId(id);
newObject.AddViewType(newTransform.typeId);
if (newTransform.typeId == ViewTypeId.Shield)
{
newObject.isShield = true;
}
newObject.AddDelayedSpawn(newTransform.typeId, newTransform.X, newTransform.Y, newTransform.Angle, TimeDelay);
newObject.AddPosition(new Vector3(newTransform.X, newTransform.Y, -0.00001f * id));
newObject.AddDirection(newTransform.Angle);
}
public void CreateArbitrary()
{
var from = new Point(1, 3, 2);
var to = new Point(4, -2, 8);
var up = new Vector(1, 1, 0);
var expected = new Matrix4x4(
-0.50709f, 0.50709f, 0.67612f, -2.36643f,
0.76772f, 0.60609f, 0.12122f, -2.82843f,
-0.35857f, 0.59761f, -0.71714f, 0,
0, 0, 0, 1);
var actual = ViewTransform.Create(from, to, up);
Assert.Equal(expected, actual);
}
private static void _ApplyGlobalTransformMatrix(ref ViewTransform vt, object _control)
{
var control = (Control)_control;
if (!control.Appearance.GetTransform(out Matrix matrix, control.Context.NowL))
{
return;
}
var rect = control.MostRecentCompositeData.Box;
var offset = (rect.Size * control.Appearance.TransformOrigin) + rect.Position;
Matrix.CreateTranslation(-offset.X, -offset.Y, 0f, out Matrix before);
Matrix.CreateTranslation(offset.X, offset.Y, 0f, out Matrix after);
// For nested non-composited transforms to work, we need to apply our transform in an unusual order
vt.ModelView = before * matrix * after * vt.ModelView;
}
private static void UpdateTransform(GameEntity entity, ViewTransform newTransform)
{
entity.isHidden = false;
entity.ReplacePosition(new Vector3(newTransform.X, newTransform.Y, entity.position.value.z));
entity.ReplaceDirection(newTransform.Angle);
var oldViewType = entity.viewType.id;
if (oldViewType != newTransform.typeId)
{
entity.isShield = newTransform.typeId == ViewTypeId.Shield;
var timeDelay = TimeDelay;
if (ViewObjectsBase.Instance.GetViewObject(oldViewType).TryGetDeathDelay(out var deathDelay))
{
timeDelay -= deathDelay;
}
entity.ReplaceViewType(newTransform.typeId);
if (entity.hasDelayedRecreation)
{
var component = new DelayedRecreationComponent
{
typeId = newTransform.typeId,
positionX = newTransform.X,
positionY = newTransform.Y,
direction = newTransform.Angle,
time = timeDelay
};
if (entity.hasManyDelayedRecreations)
{
entity.manyDelayedRecreations.components.Enqueue(component);
}
else
{
var queue = new Queue <DelayedRecreationComponent>();
queue.Enqueue(component);
entity.AddManyDelayedRecreations(queue);
}
}
else
{
entity.AddDelayedRecreation(newTransform.typeId, newTransform.X, newTransform.Y, newTransform.Angle, timeDelay);
}
}
}
public Ray RayForPixel(int pixelX, int pixelY)
{
// Offset from the edge of the canvas
var xOffset = (pixelX + 0.5) * PixelSize;
var yOffset = (pixelY + 0.5) * PixelSize;
// Untransformed coordinates of the pixel in world space
var worldX = _halfWidth - xOffset;
var worldY = _halfHeight - yOffset;
var(wasInvertible, viewInverse) = ViewTransform.Invert();
if (!wasInvertible)
{
throw new InvalidOperationException("View transform was not invertible");
}
// Transform the canvas point and origin, then compute the ray's direction vector
var pixel = viewInverse * new Point(worldX, worldY, -1);
var origin = viewInverse * new Point(0, 0, 0);
var direction = (pixel - origin).Normalize();
return(new Ray(origin, direction));
}
public iOSInspectView(UIView view, bool withSubviews = true)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
this.view = view;
PopulateTypeInformationFromObject(view);
// FIXME: special case certain view types and fill in the Description property
if (view is UILabel)
{
Description = ((UILabel)view).Text;
}
else if (view is UIButton)
{
Description = ((UIButton)view).TitleLabel.Text;
}
else if (view is UITextField)
{
Description = ((UITextField)view).Text;
}
if (!view.Transform.IsIdentity)
{
var transform = CGAffineTransform.MakeIdentity();
transform.Translate(-view.Bounds.Width * .5f, -view.Bounds.Height * .5f);
transform = CGAffineTransform.Multiply(transform, view.Transform);
transform.Translate(view.Center.X, view.Center.Y);
Transform = new ViewTransform {
M11 = transform.xx,
M12 = transform.yx,
M21 = transform.xy,
M22 = transform.yy,
OffsetX = transform.x0,
OffsetY = transform.y0
};
X = view.Bounds.X;
Y = view.Bounds.Y;
Width = view.Bounds.Width;
Height = view.Bounds.Height;
}
else
{
X = view.Frame.X;
Y = view.Frame.Y;
Width = view.Frame.Width;
Height = view.Frame.Height;
}
Kind = ViewKind.Primary;
Visibility = view.Hidden ? ViewVisibility.Collapsed : ViewVisibility.Visible;
if (!withSubviews)
{
var point = view.ConvertPointToView(
new CoreGraphics.CGPoint(0, 0),
null);
X = point.X;
Y = point.Y;
return;
}
// MKMapView has a subview that is so large (5901507x5901507 in the case encountered)
// that it causes the SceneKit camera to zoom out so much that every other node is
// effectively hidden. This should ideally be fixed in the client.
if (view is MapKit.MKMapView)
{
return;
}
var visitedLayers = new HashSet <IntPtr> ();
var subviews = view.Subviews;
if (subviews != null && subviews.Length > 0)
{
for (int i = 0; i < subviews.Length; i++)
{
var subview = new iOSInspectView(subviews [i]);
AddSubview(subview);
if (subview.Layer == null)
{
continue;
}
// After calling AddSubview, add any visited layers to the list. We track
// visited layers here so that when we actually recurse into the layer that
// belongs to this view, we don't duplicate things. This is needed because of
// the pointer-into-a-tree nature of layers, as explained above in the constructor
// remarks.
var subviewLayer = (iOSInspectView)subview.Layer;
if (subviewLayer.layer != null)
{
visitedLayers.Add(subviewLayer.layer.Handle);
}
subviewLayer.layer?.Sublayers?.ForEach(
layer => visitedLayers.Add(layer.Handle));
}
}
if (view.Layer != null && !visitedLayers.Contains(view.Layer.Handle))
{
Layer = new iOSInspectView(view, view.Layer, visitedLayers)
{
Parent = this
}
}
;
}
public WpfInspectView(FrameworkElement control, bool withSubviews = true)
{
this.control = control;
var parent = VisualTreeHelper.GetParent(control) as UIElement;
var bounds = VisualTreeHelper.GetDescendantBounds(control);
var window = Window.GetWindow(control);
if (parent == null)
{
var transformToDevice = PresentationSource.FromVisual(window).CompositionTarget.TransformToDevice;
var controlLocation = window.PointToScreen(bounds.TopLeft);
// return X and Y in application space not screen space
// so that they are in the same coordinate space as Width and Height
X = controlLocation.X / transformToDevice.M11;
Y = controlLocation.Y / transformToDevice.M22;
}
else
{
xform = (withSubviews && parent != null ?
control.TransformToAncestor(parent) :
control.TransformToVisual(Window.GetWindow(control))) as Transform;
if (xform != null)
{
Transform = new ViewTransform {
M11 = xform.Value.M11,
M12 = xform.Value.M12,
M21 = xform.Value.M21,
M22 = xform.Value.M22,
OffsetX = xform.Value.OffsetX,
OffsetY = xform.Value.OffsetY
};
}
var controlLocation = VisualTreeHelper.GetOffset(control);
X = controlLocation.X;
Y = controlLocation.Y;
}
Width = Math.Max(bounds.Width, control.RenderSize.Width);
Height = Math.Max(bounds.Height, control.RenderSize.Height);
Visibility = control.Visibility.ToViewVisibility();
PopulateTypeInformationFromObject(control);
DisplayName = control.GetType().Name;
if (!String.IsNullOrEmpty(control.Name))
{
DisplayName += " - " + control.Name;
}
if (!withSubviews)
{
var coords = control.TranslatePoint(new Point(X, Y), window);
var controlLocation = window.PointToScreen(coords);
var transformToDevice = PresentationSource.FromVisual(window).CompositionTarget.TransformToDevice;
X = controlLocation.X / transformToDevice.M11;
Y = controlLocation.Y / transformToDevice.M22;
return;
}
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(control); i++)
{
var child = VisualTreeHelper.GetChild(control, i) as FrameworkElement;
if (child == null)
{
continue;
}
AddSubview(new WpfInspectView(child));
}
}
