コード例 #1
0
        private void AddNode(CsgNode node)
        {
            if (root == null)
            {
                return;
            }
            CsgNodeWrapper      wrapper  = root.Node.Repository.GetWrapper(node);
            CsgNodeTreeViewItem item     = nodeView.SelectedItem as CsgNodeTreeViewItem;
            CsgGroupWrapper     selected = null;

            while (item != null)
            {
                selected = item.Node as CsgGroupWrapper;
                if (selected != null)
                {
                    break;
                }
                item = item.Parent as CsgNodeTreeViewItem;
            }
            if (selected == null)
            {
                selected = root.Node as CsgGroupWrapper;
            }
            if (selected != null)
            {
                selected.AddChild(wrapper);
            }
        }
コード例 #2
0
 public CsgNodeWrapper(CsgNodeWrapperRepository repo, CsgNode node)
 {
     Repository = repo;
     Node       = node;
     if (string.IsNullOrEmpty(node.Id))
     {
         node.Id = Guid.NewGuid().ToString();
     }
 }
コード例 #3
0
            public CsgNode Clone()
            {
                var node = new CsgNode();

                node.Plane    = Plane?.Clone();
                node.Front    = Front?.Clone();
                node.Back     = Back?.Clone();
                node.Polygons = Polygons.Select(p => p.Clone()).ToList();
                return(node);
            }
コード例 #4
0
        public CsgNodeWrapper GetWrapper(CsgNode node)
        {
            CsgNodeWrapper wrapper;

            if (!Wrappers.TryGetValue(node, out wrapper))
            {
                if (node is CsgCube)
                {
                    wrapper = new CsgCubeWrapper(this, (CsgCube)node);
                }
                else if (node is CsgTranslate)
                {
                    wrapper = new CsgTranslateWrapper(this, (CsgTranslate)node);
                }
                else if (node is CsgScale)
                {
                    wrapper = new CsgScaleWrapper(this, (CsgScale)node);
                }
                else if (node is CsgRotate)
                {
                    wrapper = new CsgRotateWrapper(this, (CsgRotate)node);
                }
                else if (node is CsgUnion)
                {
                    wrapper = new CsgUnionWrapper(this, (CsgUnion)node);
                }
                else if (node is CsgSubtract)
                {
                    wrapper = new CsgSubtractWrapper(this, (CsgSubtract)node);
                }
                else if (node is CsgIntersect)
                {
                    wrapper = new CsgIntersectWrapper(this, (CsgIntersect)node);
                }
                else if (node is CsgGroup)
                {
                    wrapper = new CsgGroupWrapper(this, (CsgGroup)node);
                }
                else
                {
                    wrapper = new CsgNodeWrapper(this, node);
                }
                Wrappers[node]           = wrapper;
                WrapperIds[wrapper.Id]   = wrapper;
                wrapper.PropertyChanged += WrapperPropertyChanged;
                OnObjectRootsChanged();
                SetDirty();
            }
            return(wrapper);
        }
コード例 #5
0
            public void Invert()
            {
                for (int i = 0; i < Polygons.Count; i++)
                {
                    Polygons[i].Flip();
                }
                Plane.Flip();
                Front?.Invert();
                Back?.Invert();

                var temp = Front;

                Front = Back;
                Back  = temp;
            }
コード例 #6
0
        public Csgjs Union(Csgjs csg)
        {
            if (Polygons.Count == 0)
            {
                return(csg.Clone());
            }
            if (csg.Polygons.Count == 0)
            {
                return(Clone());
            }

            var a = new CsgNode(Clone().Polygons);
            var b = new CsgNode(csg.Clone().Polygons);

            a.ClipTo(b);
            b.ClipTo(a);
            b.Invert();
            b.ClipTo(a);
            b.Invert();
            a.Build(b.AllPolygons());
            return(FromPolygons(a.AllPolygons()));
        }
コード例 #7
0
            public void Build(List <CsgPolygon> polygons)
            {
                if (polygons.Count == 0)
                {
                    return;
                }

                if (Plane == null)
                {
                    // Don't randomly choose a split plane. Coherent results are important.
                    Plane = polygons[polygons.Count / 2].Plane.Clone();
                }
                var frontPolygons = new List <CsgPolygon>();
                var backPolygons  = new List <CsgPolygon>();

                for (int i = 0; i < polygons.Count; i++)
                {
                    Plane.SplitPolygon(polygons[i], Polygons, Polygons, frontPolygons, backPolygons);
                }

                if (frontPolygons.Count > 0)
                {
                    if (Front == null)
                    {
                        Front = new CsgNode();
                    }
                    Front.Build(frontPolygons);
                }
                if (backPolygons.Count > 0)
                {
                    if (Back == null)
                    {
                        Back = new CsgNode();
                    }
                    Back.Build(backPolygons);
                }
            }
コード例 #8
0
 public void ClipTo(CsgNode bsp)
 {
     Polygons = bsp.ClipPolygons(Polygons);
     Front?.ClipTo(bsp);
     Back?.ClipTo(bsp);
 }
コード例 #9
0
        public void Dig(CsgNode shape, BoundingSphere shapeBoundary, DigMode digMode, IEnumerable <int> materialFilter)
        {
            CsgNode digShape = null;

            // constraintDiffNode performs the constraint as a CSG operation
            // by cutting away anything of thge digging shape not inside the allowed area.
            CsgOpDiff constraintDiffNode = new CsgOpDiff();

            // Assemble difference operation by applying all drone constraints.
            player.AddDroneConstraints(constraintDiffNode, shapeBoundary.Center);

            // When placing material, add a safety margin around the player to prevent it from physically glitching trough the terrain
            if (digMode == DigMode.Add)
            {
                playerNode.SetParameterFloat("playerRadius", player.Character.CharacterDiameter * 0.5f + 0.2f);
                playerNode.SetParameterVec3("playerPosition", player.Character.Position);
                playerNode.SetParameterVec3("digDirX", new vec3(1, 0, 0));
                playerNode.SetParameterVec3("digDirZ", new vec3(0, 0, 1));
                playerNode.SetParameterVec3("digDirY", new vec3(0, 0, player.Character.BodyHeight * 0.5f + 0.2f));
                constraintDiffNode.AddNode(playerNode);
            }

            // We apply the constraint by substracting it from the given shape.
            CsgOpConcat constraintedShape = new CsgOpConcat();

            constraintedShape.AddNode(shape);
            constraintedShape.AddNode(constraintDiffNode);
            digShape = constraintedShape;

            CsgNode digNode = null;

            // Depending on the digging mode, we either add or substract the digging shape from the terrain.
            if (digMode == DigMode.Substract)
            {
                digNode = new CsgOpDiff(digShape);
            }
            else
            {
                digNode = new CsgOpUnion(digShape);
            }

            // Filter for tools
            CsgNode filterNode = digNode;

            if (materialFilter != null)
            {
                CsgFilterNode filter = new CsgFilterNode(true, digNode);
                foreach (int mat in materialFilter)
                {
                    filter.AddMaterial(mat);
                }
                filter.AddMaterial(0); // Air must be white-listed, too!
                filterNode = filter;
            }

            // Float elimination
            CsgOpConcat collapser = new CsgOpConcat(filterNode);

            collapser.AddNode(new CsgCollapseNode());

            // Callback for statistical purposes.
            CsgStatCallback finalNode = new CsgStatCallback(collapser, 4, 4);

            finalNode.AddSimpleVolumeCallback("UpvoidMiner", UpvoidMiner.ModDomain, "UpvoidMiner.DiggingController", "StatCallback");
            finalNode.AddVolumeChangePointCallback("UpvoidMiner", UpvoidMiner.ModDomain, "UpvoidMiner.DiggingController", "PointCallback");

            world.Terrain.ModifyTerrain(shapeBoundary, finalNode);
        }
コード例 #10
0
        protected virtual void UpdateModel()
        {
            while (viewport.Children.Count > 1)
            {
                viewport.Children.RemoveAt(1);
            }
            CsgNodeWrapper wrapper   = null;
            bool           resetView = lastModel == null;

            if (LockToggle.IsChecked.GetValueOrDefault())
            {
                wrapper = lastModel; lastModel.IsViewing = true;
            }
            else if (lastModel != null)
            {
                lastModel.IsViewing = false;
            }
            if (wrapper == null)
            {
                wrapper = SelectedItem;
            }
            if (lastModel != null)
            {
                lastModel.MeshChanged -= ModelMeshChanged; lastModel = null;
            }
            if (wrapper == null)
            {
                return;
            }
            CsgNode root = wrapper.Node;

            lastModel              = wrapper;
            lastModel.MeshChanged += ModelMeshChanged;
            modelMin = new Point3D(double.MaxValue, double.MaxValue, double.MaxValue);
            modelMax = new Point3D(double.MinValue, double.MinValue, double.MinValue);
            meshGeometry.Clear();
            foreach (Mesh3 mesh in GetMeshes())
            {
                mesh.CalculateNormals();
                viewport.Children.Add(new ModelVisual3D()
                {
                    Content = meshGeometry[mesh] = new GeometryModel3D()
                    {
                        Material = defaultMaterial,
                        Geometry = new MeshGeometry3D()
                        {
                            TriangleIndices = new Int32Collection(mesh.TriangleIndices),
                            Normals         = new Vector3DCollection(mesh.VertexNormals.Select(x => new Vector3D(x.X, x.Y, x.Z)).ToArray()),
                            Positions       = new Point3DCollection(mesh.Vertices.Select(x =>
                            {
                                Vector3 transformed = mesh.Transform.Transform(x) + mesh.Position;
                                if (transformed.X < modelMin.X)
                                {
                                    modelMin.X = transformed.X;
                                }
                                if (transformed.X > modelMax.X)
                                {
                                    modelMax.X = transformed.X;
                                }
                                if (transformed.Y < modelMin.Y)
                                {
                                    modelMin.Y = transformed.Y;
                                }
                                if (transformed.Y > modelMax.Y)
                                {
                                    modelMax.Y = transformed.Y;
                                }
                                if (transformed.Z < modelMin.Z)
                                {
                                    modelMin.Z = transformed.Z;
                                }
                                if (transformed.Z > modelMax.Z)
                                {
                                    modelMax.Z = transformed.Z;
                                }
                                return(new Point3D(x.X, x.Y, x.Z));
                            }).ToArray())
                        },
                        Transform = new MatrixTransform3D(mesh.Transform.ToMatrix3D(mesh.Position))
                    }
                });
            }
            if (resetView)
            {
                ResetView();
            }
        }