public void RenderActor(SceneActor item)
{
if (VisualFactory == null)
{
DebugUtil.LogWithLocation("No visual factory provided for viewport");
}
else
{
Visual3D visual;
//Check if we need to use a dummy visual
if (item.Geometry != null)
{
visual = VisualFactory.GetVisual(RenderingMode.Solid, item);
}
else
{
visual = VisualFactory.GetDummyVisual();
}
actorsVisuals.Add(new Tuple <LibTransform, Visual3D>(item.Transform, visual));
//Set a position for the visual
AegirLib.MathType.Matrix m = item.Transform.TransformMatrix;
Matrix3D matrix = new Matrix3D(m.M11, m.M12, m.M13, m.M14,
m.M21, m.M22, m.M23, m.M24,
m.M31, m.M32, m.M33, m.M34,
m.M41, m.M42, m.M43, m.M44);
MatrixTransform3D matrixTransform = new MatrixTransform3D(matrix);
visual.Transform = matrixTransform;
Scene.Children.Add(visual);
}
}
public PhysicCore(SceneActor actor) : base(actor)
{
_velocity = new Vector2(0, 0);
AngularSpeed = 0;
sceneActor = actor;
SetActive(true);
}
protected override Visual3D CreateVisual(SceneActor renderItem)
{
MeshGeometryVisual3D visual = new MeshGeometryVisual3D();
visual.MeshGeometry = renderItem.Geometry;
visual.Material = new DiffuseMaterial(new SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 122, 122, 122)));
return(visual);
////Need to Vertexes to points3d
//List<Point3D> vertexes = new List<Point3D>();
//foreach(Vector3 v in model.Vertices)
//{
// vertexes.Add(new Point3D(v.X, v.Y, v.Z));
//}
////Collapse indices to one list
//List<int> indices = new List<int>();
//indices.AddRange(model.Faces);
////Create normals on wpf vector format
//List<Vector3D> normals = new List<Vector3D>();
//foreach(Vector3 vn in model.VertexNomals)
//{
// normals.Add(new Vector3D(vn.X, vn.Y, vn.Z));
//}
//if(normals.Count == 0)
//{
// meshBuilder.Append(vertexes, indices);
//}
//else
//{
// meshBuilder.Append(vertexes, indices, normals);
//}
//return meshBuilder.ToMesh();
}
public async Task <ActionResult <SceneActor> > PostSceneActor(SceneActor sceneActor)
{
_context.SceneActors.Add(sceneActor);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSceneActor", new { id = sceneActor.Id }, sceneActor));
}
private void Viewport_MouseUp(object sender, MouseButtonEventArgs e)
{
if (e.ChangedButton == MouseButton.Left)
{
DebugUtil.LogWithLocation("Clicked on viewport");
HelixViewport3D viewport = (HelixViewport3D)sender;
var overlayHit = viewport.Viewport
.FindHits(e.GetPosition(Overlay))
.FirstOrDefault();
if (overlayHit != null)
{
//do something
}
else
{
//no hit in overlay
//check if this hits anything in the underlaying viewport
var scenehit = viewport.Viewport
.FindHits(e.GetPosition(Scene))
.FirstOrDefault();
if (scenehit != null)
{
SceneActor selectedActor
= VisualFactory?.GetRenderItem(RenderingMode.Solid, scenehit.Visual);
if (selectedActor != null)
{
ActorClicked?.Invoke(selectedActor.Transform.Parent);
}
}
}
}
}
public async Task <IActionResult> PutSceneActor([FromRoute] int id, [FromBody] SceneActor sceneActor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != sceneActor.SceneId)
{
return(BadRequest());
}
_context.Entry(sceneActor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SceneActorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PostSceneActor([FromBody] SceneActor sceneActor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.SceneActor.Add(sceneActor);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SceneActorExists(sceneActor.SceneId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetSceneActor", new { id = sceneActor.SceneId }, sceneActor));
}
public override void Init(Main m, SceneActor actor, EditValue ev)
{
this.resetValue = ev.val.Clone();
base.Init(m, actor, ev);
resetButton.onClick.AddListener(this.OnButtonReset);
}
protected override void Act()
{
SceneActor sceneActor = actingInScene.GetSceneActor(actorName);
sceneActor.PlayCustomAnimation(clip, crossFadeDuration);
ComponentDone();
}
public PolygonCollider(SceneActor actor, Polygon polygon, CollisionWorld collisionWorld, int layer) : base(actor)
{
colliderObject = new PolygonColliderObject(polygon, actor.Transform);
AddSubObject(colliderObject);
indexInWorld = collisionWorld.AddCollider(colliderObject, layer);
this.collisionWorld = collisionWorld;
this.layer = layer;
colliderObject.OnCollide += ColliderObject_OnCollide;
}
public override void OnActorAdded(SceneActor actor)
{
if (this.showAllToggle.isOn == false)
{
return;
}
CreateActorTreeNode(actor);
}
/// <summary>
/// Create an tree node for an actor and populate it with the correct
/// contents.
/// </summary>
/// <param name="actor">The actor to add to the tree.</param>
public void CreateActorTreeNode(SceneActor actor)
{
PxPre.Tree.Node actorNode = this.tree.AddNode("Actor", this.nodeShapes);
RefreshActorNodeIcons(actor, actorNode);
this.nodeToActor.Add(actorNode, actor);
this.actorToNode.Add(actor, actorNode);
this.actorToParams.Add(actor, new NodeWidgets());
this.RefreshActorParams(actor);
}
protected override Visual3D CreateVisual(SceneActor renderItem)
{
LinesVisual3D wireframeVisual = new LinesVisual3D();
wireframeVisual.Points = renderItem.Geometry.Positions;
wireframeVisual.Thickness = 2;
wireframeVisual.Color = Color.FromArgb(255, 0, 180, 20);
return(wireframeVisual);
}
private void _PrepareCameras(Scene scene, SceneActor moveableObject)
{
foreach (KeyValuePair <String, Camera> cameraInfo in _GetCameras(moveableObject))
{
scene.AddCamera(cameraInfo.Key, cameraInfo.Value);
}
scene.SetCamera("Constant");
}
IEnumerator restartLevel()
{
yield return(new WaitForSeconds(2));
SceneActor.resetPosition();
mySprite.color = Color.white;
hateDistance = 1f;
hitPoints = 3;
coins = Savepoint.StoredGold;
}
private IEnumerable <SceneActor> _GetPlaneMesh(Model[] planeModels, Color color, Vector3 startPos, int rows, int cols)
{
Func <Random, Vector3> getRandomVector = (rr => new Vector3((float)rr.NextDouble(), (float)rr.NextDouble(), (float)rr.NextDouble()));
Random random = new Random();
SceneActor tmpActor = new SceneActor(planeModels, Vector3.Zero, Color.Gray);
return(_GetPositionsOfMesh(startPos, rows, cols, 2, 2)
.Select(position => new SceneActor(planeModels, position, color,
new ReflectanceFactors(Vector3.Zero, getRandomVector(random), getRandomVector(random), random.Next(2, 200)))));
}
public Visual3D GetVisual(SceneActor renderItem)
{
if (visualCache.ContainsKey(renderItem))
{
return(visualCache[renderItem]);
}
Visual3D visual = CreateVisual(renderItem);
visualCache[renderItem] = visual;
return(visual);
}
public override void OnActorDeleted(SceneActor actor)
{
if (this.actorToNode.TryGetValue(actor, out PxPre.Tree.Node n) == true)
{
this.actorToNode.Remove(actor);
this.nodeToActor.Remove(n);
n.Destroy();
this.actorToParams[actor].Destroy();
this.actorToParams.Remove(actor);
}
}
public IAvatar GetMainAvatar()
{
SceneActor mainActor = FindSceneActor("Tyra");
if (mainActor == null)
{
return(null);
}
var avatar = mainActor.GetComponentInChildren <CharacterAvatar>();
return(avatar);
}
public override void Draw(SceneActor drawableObject)
{
_SetEffectParameters(drawableObject);
MeshesInfo meshInfo = drawableObject.CurrentMesh;
for (int i = 0; i < meshInfo.LocalToGlobalMatrices.Count; ++i)
{
_SetWorldMatrices(meshInfo.LocalToGlobalMatrices[i], drawableObject.WorldMatrix);
_DrawTriangles(meshInfo.SmoothVertices[i]);
}
}
protected void _SetEffectParameters(SceneActor drawableObject)
{
_effect.Parameters["View"].SetValue(_drawingKit.ViewMatrix);
_effect.Parameters["ViewerPosition"].SetValue(_drawingKit.ViewerPosition);
_effect.Parameters["Projection"].SetValue(_drawingKit.ProjectionMatrix);
_effect.Parameters["LightsNum"].SetValue(_drawingKit.LightingInfo.Count);
_effect.Parameters["LightPosition"].SetValue(_drawingKit.LightingInfo.Positions);
_effect.Parameters["LightColor"].SetValue(_drawingKit.LightingInfo.Colors);
_effect.Parameters["Shininess"].SetValue(drawableObject.ReflectanceFactors.Shininess);
_effect.Parameters["ka"].SetValue(drawableObject.ReflectanceFactors.Ambient);
_effect.Parameters["kd"].SetValue(drawableObject.ReflectanceFactors.Diffuse);
_effect.Parameters["ks"].SetValue(drawableObject.ReflectanceFactors.Specular);
}
public override void Init(Main m, SceneActor actor, EditValue ev)
{
base.Init(m, actor, ev);
this.input.onEndEdit.AddListener(
(x) =>
{
this.OnTextChange();
});
SetupWidgetDrag(this.Mgr, this.actor, this.btnSpinner, this.EV, this);
this.OnUpdateValue();
}
public override void Init(Main m, SceneActor actor, EditValue ev)
{
base.Init(m, actor, ev);
this.toggle.onValueChanged.AddListener(
(x) =>
{
this.EV.val.SetBool(this.toggle.isOn);
this.OnUpdateValue();
this.Mgr.NotifyActorModified(this.actor, ev.name);
});
this.OnUpdateValue();
}
public async Task <ActionResult <SceneTool> > PostSceneActor(SceneActor sceneActor)
{
_context.SceneActor.Add(sceneActor);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
throw;
}
return(CreatedAtAction("GetSceneTool", new { id = sceneActor.UserName }, sceneActor));
}
private Dictionary <String, Camera> _GetCameras(SceneActor moveableObject)
{
Vector3 CONSTANT_CAMERA_POSITION = new Vector3(0, 0, -20);
Dictionary <String, Camera> res = new Dictionary <string, Camera>();
res.Add("Constant", new Camera(CONSTANT_CAMERA_POSITION, Vector3.Zero));
res.Add("MoveableObjectCamera", new MoveableObjectCamera(moveableObject));
res.Add("StationaryObjectCamera", new StationaryObjectCamera(CONSTANT_CAMERA_POSITION, moveableObject));
return(res);
}
public void RemoveActor(SceneActor actor)
{
Tuple <LibTransform, Visual3D> toRemove = actorsVisuals
.FirstOrDefault(x => x.Item1 == actor.Transform);
if (toRemove != null)
{
Scene.Children.Remove(toRemove.Item2);
actorsVisuals.Remove(toRemove);
}
else
{
DebugUtil.LogWithLocation("Tried to remove Actor not in scene");
}
}
public Visual3D GetVisual(RenderingMode mode, SceneActor item)
{
if (providers.ContainsKey(mode))
{
Visual3D visual = providers[mode].GetVisual(item);
if (visual == null)
{
Aegir.Util.DebugUtil.LogWithLocation($"Provider for {mode} was defined but returned null");
}
return(visual);
}
else
{
Aegir.Util.DebugUtil.LogWithLocation($"No provider for rendering mode {mode}, no visual created");
return(null);
}
}
public override void OnActorSelected(SceneActor actor)
{
if (this.showAllToggle.isOn == false)
{
this.RebuildActorTree();
}
else if (actor != null)
{
if (this.actorToNode.TryGetValue(actor, out PxPre.Tree.Node v) == true)
{
this.tree.SelectNode(v, true);
}
}
else
{
this.tree.DeselectAll();
}
}
public override void OnActorModified(SceneActor actor, string paramName)
{
if (actor == null)
{
if (paramName == "Decay")
{
this.decayEd.OnUpdateValue();
}
return;
}
NodeWidgets nw;
if (this.actorToParams.TryGetValue(actor, out nw) == false)
{
return;
}
NodeWidgets.ParamNodePair pnp;
if (nw.widgets.TryGetValue(paramName, out pnp) == false)
{
return;
}
pnp.param.OnUpdateValue();
EditValue?ev = actor.GetParam(paramName);
if (ev.HasValue)
{
if (
ev.Value.val.ty == Val.Type.Enum ||
ev.Value.val.ty == Val.Type.Bool)
{
RefreshActorParams(actor);
if (this.actorToNode.TryGetValue(actor, out PxPre.Tree.Node v) == true)
{
RefreshActorNodeIcons(actor, v);
}
}
}
}
/// <summary>
/// Makes sure the parameters shown for a specific actor is correct.
/// </summary>
/// <param name="actor">The actor to refresh for.</param>
void RefreshParamPositions(SceneActor actor)
{
PxPre.Tree.Node node;
if (this.actorToNode.TryGetValue(actor, out node) == false)
{
return;
}
NodeWidgets nw;
if (this.actorToParams.TryGetValue(actor, out nw) == false)
{
return;
}
if (node.IsVisible() == false || node.Expanded == false)
{
foreach (KeyValuePair <string, NodeWidgets.ParamNodePair> kvp in nw.widgets)
{
kvp.Value.param.gameObject.SetActive(false);
}
}
else
{
foreach (KeyValuePair <string, NodeWidgets.ParamNodePair> kvp in nw.widgets)
{
RectTransform rt = this.tree.GetNodeRectTransform(kvp.Value.node);
if (rt == null)
{
kvp.Value.param.gameObject.SetActive(false);
continue;
}
kvp.Value.param.gameObject.SetActive(true);
RectTransform rtParam = kvp.Value.param.rectTransform;
const float horizPadd = 5.0f;
rtParam.anchorMin = new Vector2(0.0f, 1.0f);
rtParam.anchorMax = new Vector2(1.0f, 1.0f);
rtParam.offsetMin = new Vector2(horizPadd, Mathf.Min(rt.offsetMin.y, rt.offsetMax.y - kvp.Value.node.MinHeight));
rtParam.offsetMax = new Vector2(-horizPadd, rt.offsetMax.y);
}
}
}
