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); } } }