コード例 #1
0
        private void StartDragging(float3 handPos, ref HandState state)
        {
            if (state.HoveredVertex == Entity.Null || !EntityManager.GetSelected(state.HoveredVertex))
            {
                EntityManager.DeselectAll();

                if (state.HoveredVertex != Entity.Null)
                {
                    EntityManager.SetSelected(state.HoveredVertex, true);
                }
            }

            state.IsDragging  = true;
            state.DragOrigin  = handPos;
            state.DragApplied = float3.zero;

            HybridLevel.SetDragOffset(-state.DragApplied);

            if (state.HoveredVertex != Entity.Null)
            {
                var vertex = EntityManager.GetComponentData <Vertex>(state.HoveredVertex);

                _gridOrigin.y = vertex.MinY;
            }
        }
コード例 #2
0
        private void StopDragging(ref HandState state)
        {
            HybridLevel.SetDragOffset(Vector3.zero);

            EntityManager.AddComponent <MergeOverlappingVertices>(Level);

            state.IsDragging = false;
        }
コード例 #3
0
        private void StartDragging(float3 handPos, ref HandState state)
        {
            if (state.HoveredFloorCeiling == Entity.Null || !EntityManager.GetSelected(state.HoveredFloorCeiling))
            {
                EntityManager.DeselectAll();

                if (state.HoveredFloorCeiling != Entity.Null)
                {
                    EntityManager.SetSelected(state.HoveredFloorCeiling, true);
                }
            }

            state.IsDragging  = true;
            state.DragOrigin  = handPos;
            state.DragApplied = float3.zero;

            HybridLevel.SetDragOffset(-state.DragApplied);
        }
コード例 #4
0
        private void UpdateDragging(Hand hand, float3 handPos, ref HandState state)
        {
            _gridOrigin.x = handPos.x;
            _gridOrigin.z = handPos.z;

            var offset = handPos - state.DragOrigin - state.DragApplied;

            var intOffset = new int3(math.round(offset / GridSnap))
            {
                x = 0, z = 0
            };

            if (math.lengthsq(intOffset) <= 0)
            {
                return;
            }

            if (Extrude && !state.HasExtruded)
            {
                StartExtrude(intOffset.y > 0, ref state);
            }

            offset = new float3(intOffset) * GridSnap;

            state.DragApplied += offset;
            HybridLevel.SetDragOffset(-state.DragApplied);

            var selectedEntities = _getSelectedFloorCeilings.ToEntityArray(Allocator.TempJob);
            var moves            = new NativeArray <Move>(selectedEntities.Length, Allocator.TempJob);

            var move = new Move {
                Offset = offset
            };

            for (var i = 0; i < moves.Length; ++i)
            {
                moves[i] = move;
            }

            EntityManager.AddComponentData(_getSelectedFloorCeilings, moves);

            selectedEntities.Dispose();
            moves.Dispose();
        }
コード例 #5
0
        private void UpdateDragging(Hand hand, float3 handPos, ref HandState state)
        {
            _gridOrigin.x = handPos.x;
            _gridOrigin.z = handPos.z;

            var offset = handPos - state.DragOrigin;

            if (AxisAlignAction.GetState(hand.handType))
            {
                var threshold = math.tan(math.PI / 8f);

                var xScore = math.abs(offset.x);
                var zScore = math.abs(offset.z);

                if (xScore * threshold > zScore)
                {
                    offset.z = 0f;
                }
                else if (zScore * threshold > xScore)
                {
                    offset.x = 0f;
                }
                else
                {
                    var avg = (xScore + zScore) * 0.5f;
                    offset.x = math.sign(offset.x) * avg;
                    offset.z = math.sign(offset.z) * avg;
                }
            }

            offset -= state.DragApplied;

            var intOffset = new int3(math.round(offset / GridSnap))
            {
                y = 0
            };

            if (math.lengthsq(intOffset) <= 0)
            {
                return;
            }

            offset = new float3(intOffset) * GridSnap;

            state.DragApplied += offset;
            HybridLevel.SetDragOffset(-state.DragApplied);

            var selectedEntities = _getSelectedVertices.ToEntityArray(Allocator.TempJob);
            var moves            = new NativeArray <Move>(selectedEntities.Length, Allocator.TempJob);

            var move = new Move {
                Offset = offset
            };

            for (var i = 0; i < moves.Length; ++i)
            {
                moves[i] = move;
            }

            EntityManager.AddComponentData(_getSelectedVertices, moves);

            selectedEntities.Dispose();
            moves.Dispose();
        }