public static NPVoxBoneModel MatrixTransform(NPVoxBoneModel sourceModel, NPVoxBox affectedArea, uint boneMask, Matrix4x4 matrix, Vector3 pivot, ResolveConflictMethodType resolveConflictMethod = ResolveConflictMethodType.CLOSEST, NPVoxModel reuse = null, byte markColor = 0)
    {
        Vector3   pivotPoint      = affectedArea.SaveCenter + pivot;
        Matrix4x4 transformMatrix = (Matrix4x4.TRS(pivotPoint, Quaternion.identity, Vector3.one) * matrix) * Matrix4x4.TRS(-pivotPoint, Quaternion.identity, Vector3.one);

        return(Transform(sourceModel, affectedArea, boneMask, transformMatrix, resolveConflictMethod, reuse, markColor));
    }
    public void SetBoneMask(uint mask, bool includingDescendants)
    {
        NPVoxBoneModel transformedModel = CurrentModelFactory.GetProduct() as NPVoxBoneModel;

        NPVoxBone[] allBones = ((NPVoxBoneModel)transformedModel).AllBones;
        SetBoneMask(includingDescendants ? NPVoxBone.GetMaskWithDescendants(ref allBones, mask) : mask);
    }
예제 #3
0
    public new static NPVoxBoneModel NewInstance(NPVoxCoord size, NPVoxModel reuse = null)
    {
        NPVoxBoneModel VoxModel = reuse is NPVoxBoneModel ? reuse as NPVoxBoneModel : ScriptableObject.CreateInstance <NPVoxBoneModel>();

        VoxModel.name = "BoneModel";
        VoxModel.Initialize(size);
        return(VoxModel);
    }
예제 #4
0
 public override void CopyOver(NPVoxModel source)
 {
     base.CopyOver(source);
     if (source is NPVoxBoneModel)
     {
         NPVoxBoneModel boneModel = (source as NPVoxBoneModel);
         boneMasks     = (uint[])boneModel.boneMasks.Clone();
         this.AllBones = NPVoxBone.CloneBones(boneModel.AllBones);
     }
 }
예제 #5
0
    // ===================================================================================================
    // Tools
    // ===================================================================================================

    public void RecenterBonePivot(NPVoxBoneModel model)
    {
        NPVoxBone[] bones = NPVoxBone.GetRootBones(ref model.AllBones, NPVoxBone.GetBonesInMask(ref model.AllBones, boneMask));
        if (bones.Length == 1)
        {
            Vector3 pivotOrigin        = GetAffectedBox().SaveCenter;
            Vector3 pivotForSingleBone = model.GetAffectedArea(1u << (bones[0].ID - 1)).SaveCenter;
            PivotOffset = pivotForSingleBone - pivotOrigin;
        }
    }
예제 #6
0
    override public void ResetSceneTools()
    {
        PivotOffset = Vector3.zero;
        Matrix      = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, Vector3.one);

        if (Input != null)
        {
            NPVoxBoneModel model = ((NPVoxIModelFactory)Input).GetProduct() as NPVoxBoneModel;
            RecenterBonePivot(model);
        }
    }
예제 #7
0
    private bool DrawBoneSelection()
    {
        if (viewModel.PreviousModelFactory == null)
        {
            return(false);
        }
        NPVoxBoneModel previewModel = viewModel.EditorModelFactory.GetProduct() as NPVoxBoneModel;

        if (previewModel == null)
        {
            return(false);
        }

        if (!viewModel.IsBoneSelectionActive())
        {
            return(false);
        }

        NPVoxToUnity npVoxToUnity = new NPVoxToUnity(previewModel, viewModel.Animation.MeshFactory.VoxelSize);

        // affected area picker
        if (Event.current.isMouse && Event.current.type == EventType.MouseDown && Event.current.button == 0)
        {
//            NPVoxCoord someCoord = NPVoxCoord.INVALID;
            float  mouseScale = NPVoxHandles.GetMouseScale(SceneView.currentDrawingSceneView.camera);
            Camera cam        = SceneView.currentDrawingSceneView.camera;
            Ray    r          = SceneView.currentDrawingSceneView.camera.ScreenPointToRay(
                new Vector3(Event.current.mousePosition.x * mouseScale, -Event.current.mousePosition.y * mouseScale + Camera.current.pixelHeight)
                );
            NPVoxRayCastHit raycastHit = npVoxToUnity.Raycast(r, ((NPVoxAnimationEditorSession)target).previewFilter.transform, 20);
            if (raycastHit.IsHit)
            {
                uint boneMask = previewModel.GetBoneMask(raycastHit.Coord);
                if (boneMask != 0)
                {
                    if (Event.current.control || Event.current.command)
                    {
                        viewModel.ToggleBoneMask(boneMask, Event.current.shift);
                    }
                    else
                    {
                        viewModel.SetBoneMask(boneMask, Event.current.shift);
                    }
                }
            }
        }
        return(true);
    }
    public void ToggleBoneMask(uint mask, bool includingDescendants)
    {
        NPVoxSkeletonTransformer t = ((NPVoxSkeletonTransformer)SelectedTransformer);
        NPVoxBoneModel           transformedModel = CurrentModelFactory.GetProduct() as NPVoxBoneModel;

        NPVoxBone[] allBones   = ((NPVoxBoneModel)transformedModel).AllBones;
        uint        toggleMask = includingDescendants ? NPVoxBone.GetMaskWithDescendants(ref allBones, mask) : mask;

        if ((mask & t.BoneMask) != 0)
        {
            SetBoneMask(t.BoneMask & ~toggleMask);
        }
        else
        {
            SetBoneMask(t.BoneMask | toggleMask);
        }
    }
예제 #9
0
 // ===================================================================================================
 // Name
 // ===================================================================================================
 protected void RegenerateName(NPVoxBoneModel model)
 {
     if (regenerateName)
     {
         regenerateName = false;
         NPVoxBone[] bones = NPVoxBone.GetRootBones(ref model.AllBones, NPVoxBone.GetBonesInMask(ref model.AllBones, boneMask));
         string      name  = "";
         foreach (NPVoxBone bone in bones)
         {
             if (!string.IsNullOrEmpty(name))
             {
                 name += ", ";
             }
             name += bone.Name;
         }
         this.InstanceName = name;
     }
 }
    public System.Func <NPVoxISceneEditable, bool> DrawSceneTool(NPVoxToUnity npVoxToUnity, UnityEngine.Transform transform, int tool)
    {
        // offset

        if (CurrentEditedBone == null)
        {
            return(null);
        }

        NPVoxBoneModel boneModel = GetProduct() as NPVoxBoneModel;

        if (boneModel == null)
        {
            return(null);
        }

        if (lastMask != 1u << (CurrentEditedBone.ID - 1))
        {
            lastMask     = 1u << (CurrentEditedBone.ID - 1);
            currentPivot = npVoxToUnity.ToUnityPosition(boneModel.GetAffectedArea(lastMask).SaveCenter);
        }

        Vector3 offset = npVoxToUnity.ToUnityDirection(CurrentEditedBone.Anchor);

        if (tool == 0)
        {
            offset = npVoxToUnity.ToSaveVoxDirection(Handles.PositionHandle(currentPivot + offset, Quaternion.identity) - currentPivot);
            if (offset != CurrentEditedBone.Anchor)
            {
                return((NPVoxISceneEditable t) =>
                {
                    NPVoxBone.GetBoneByID(ref ((NPVoxSkeletonBuilder)t).AllBones, CurrentEditedBone.ID).Anchor = offset;
                    return true;
                });
            }
        }

        return(null);
    }
    override protected NPVoxModel CreateProduct(NPVoxModel reuse = null)
    {
        if (Input == null)
        {
            return(NPVoxModel.NewInvalidInstance(reuse, "No Input Setup"));
        }

        NPVoxModel model = ((NPVoxIModelFactory)Input).GetProduct();

        if (model is NPVoxBoneModel)
        {
            Debug.LogError("cannot create bone model on top of another bone model");
            return(model);
        }

        NPVoxBoneModel newModel = NPVoxBoneModel.NewInstance(model.Size, reuse as NPVoxBoneModel);

        newModel.CopyOver(model);

        // setup bone masks
        newModel.AllBones = NPVoxBone.CloneBones(AllBones);
        for (int i = 0; i < AllBones.Length; i++)
        {
            NPVoxBone       bone  = AllBones[i];
            List <NPVoxBox> boxes = AllBoxes[i].Boxes;
            if (boxes != null)
            {
                foreach (NPVoxBox box in boxes)
                {
                    foreach (NPVoxCoord coord in box.Enumerate())
                    {
                        newModel.AddBoneMask(coord, 1u << (bone.ID - 1));
                    }
                }
            }
        }

        return(newModel);
    }
예제 #12
0
    override protected NPVoxModel CreateProduct(NPVoxModel reuse = null)
    {
        if (Input == null)
        {
            return(NPVoxModel.NewInvalidInstance(reuse, "No Input Setup"));
        }

        NPVoxBoneModel model = ((NPVoxIModelFactory)Input).GetProduct() as NPVoxBoneModel;

        if (model == null)
        {
            return(NPVoxModel.NewInvalidInstance(reuse, "Can only transform bone models"));
        }

        // hack to center pivot on selected bones
        if (regenerateName)
        {
            RecenterBonePivot(model);
        }

        RegenerateName(model);

        NPVoxBox affectedBox = GetAffectedBox();

        if (affectedBox.Equals(NPVoxBox.INVALID))
        {
            NPVoxModel newInstance = NPVoxModel.NewInstance(model, reuse);
            newInstance.CopyOver(model);
            newInstance.RecalculateNumVoxels(true);
            return(newInstance);
        }
        else
        {
            reuse = NPVoxModelTransformationUtil.MatrixTransform(model, affectedBox, boneMask, Matrix, PivotOffset, ResolveConflictMethod, reuse);
            reuse.RecalculateNumVoxels(true);
            return(reuse);
        }
    }
예제 #13
0
    public NPVoxBox GetAffectedBox()
    {
        if (Input == null)
        {
            Debug.Log("Input was NULL");
            return(NPVoxBox.INVALID);
        }

        NPVoxBoneModel affectedAreaSourceModel = (Input as NPVoxIModelFactory).GetProduct() as NPVoxBoneModel;

        if (affectedAreaSourceModel == null)
        {
            Debug.Log("Input did not procue a bone model");
            return(NPVoxBox.INVALID);
        }

        if (affectedAreaSourceModel == this.lastAffectedAreaSourceModel && this.lastAffectedAreaSourceModelVersion == affectedAreaSourceModel.GetVersion() && lastAffectedAreaBoneMask == this.boneMask)
        {
            return(lastAffectedArea);
        }

        NPVoxBox affectedArea = affectedAreaSourceModel.GetAffectedArea(boneMask);

        this.lastAffectedArea = affectedArea;
        this.lastAffectedAreaSourceModelVersion = affectedAreaSourceModel.GetVersion();
        this.lastAffectedAreaSourceModel        = affectedAreaSourceModel;
        this.lastAffectedAreaBoneMask           = this.boneMask;

        if (lastAffectedArea == null)
        {
            lastAffectedArea = NPVoxBox.INVALID;
        }

//        Debug.Log("Recalculate Affected Area");

        return(lastAffectedArea);
    }
    public static NPVoxModel Transform(NPVoxModel sourceModel, NPVoxBox affectedArea, Matrix4x4 transformMatrix, ResolveConflictMethodType resolveConflictMethod = ResolveConflictMethodType.CLOSEST, NPVoxModel reuse = null)
    {
        NPVoxBox clampedBox = sourceModel.Clamp(affectedArea);

        // calculate size & offset for new model
        NPVoxCoord size   = sourceModel.Size;
        NPVoxCoord offset = NPVoxCoord.ZERO;
        {
            NPVoxBox parentBounds = sourceModel.BoundingBox;
            NPVoxBox thisBounds   = parentBounds.Clone();

            // transform voxels
            foreach (NPVoxCoord coord in clampedBox.Enumerate())
            {
                Vector3    saveCoord = transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(coord));
                NPVoxCoord newCoord  = NPVoxCoordUtil.ToCoord(saveCoord);
                if (!sourceModel.IsInside(newCoord))
                {
                    thisBounds.EnlargeToInclude(newCoord);
                }
            }
            // transform sockets
            foreach (NPVoxSocket socket in sourceModel.Sockets)
            {
                NPVoxCoord newCoord = NPVoxCoordUtil.ToCoord(transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(socket.Anchor)));
                if (clampedBox.Contains(socket.Anchor) && !sourceModel.IsInside(newCoord))
                {
                    thisBounds.EnlargeToInclude(newCoord);
                }
            }

            CalculateResizeOffset(parentBounds, thisBounds, out offset, out size);
        }


        bool           hasVoxelGroups  = sourceModel.HasVoxelGroups();
        NPVoxBoneModel sourceBoneModel = sourceModel as NPVoxBoneModel;
        bool           hasBoneGropus   = sourceBoneModel != null;

        NPVoxModel     transformedModel     = NPVoxModel.NewInstance(sourceModel, size, reuse);
        NPVoxBoneModel transformedBoneModel = transformedModel as NPVoxBoneModel;

        if (hasVoxelGroups)
        {
            transformedModel.InitVoxelGroups();
            transformedModel.NumVoxelGroups = sourceModel.NumVoxelGroups;
        }
        if (hasBoneGropus)
        {
            transformedBoneModel.AllBones = NPVoxBone.CloneBones(sourceBoneModel.AllBones);
        }

        // 1. copy all voxels over that are not affected by the transformation
        transformedModel.NumVoxels  = sourceModel.NumVoxels;
        transformedModel.Colortable = sourceModel.Colortable;
        foreach (NPVoxCoord coord in sourceModel.EnumerateVoxels())
        {
            NPVoxCoord movedCoord = coord + offset;
            if (!clampedBox.Contains(coord))
            {
                transformedModel.SetVoxel(movedCoord, sourceModel.GetVoxel(coord));
                if (hasVoxelGroups)
                {
                    transformedModel.SetVoxelGroup(movedCoord, sourceModel.GetVoxelGroup(coord));
                }
                if (hasBoneGropus)
                {
                    transformedBoneModel.SetBoneMask(movedCoord, sourceBoneModel.GetBoneMask(coord));
                }
            }
        }

        // 2. copy all voxels that can be tranformed without conflict,
        Dictionary <NPVoxCoord, Vector3> conflictVoxels = new Dictionary <NPVoxCoord, Vector3>();

        foreach (NPVoxCoord sourceCoord in clampedBox.Enumerate())
        {
            if (sourceModel.HasVoxelFast(sourceCoord))
            {
                Vector3    saveCoord       = transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(sourceCoord));
                Vector3    targetCoordSave = saveCoord + NPVoxCoordUtil.ToVector(offset);
                NPVoxCoord targetCoord     = NPVoxCoordUtil.ToCoord(targetCoordSave);

                if (!transformedModel.HasVoxelFast(targetCoord))
                {
                    transformedModel.SetVoxel(targetCoord, sourceModel.GetVoxel(sourceCoord));
                    if (hasVoxelGroups)
                    {
                        transformedModel.SetVoxelGroup(targetCoord, sourceModel.GetVoxelGroup(sourceCoord));
                    }
                    if (hasBoneGropus)
                    {
                        transformedBoneModel.SetBoneMask(targetCoord, sourceBoneModel.GetBoneMask(sourceCoord));
                    }
                }
                else
                {
                    conflictVoxels[sourceCoord] = targetCoordSave;
                }
            }
        }

        // 3. try to fit in voxels that had conflicts
        int numberOfConflictsSolved = 0;

        if (resolveConflictMethod != ResolveConflictMethodType.NONE)
        {
            foreach (NPVoxCoord sourceCoord in conflictVoxels.Keys)
            {
                if (sourceModel.HasVoxelFast(sourceCoord))
                {
                    Vector3    targetSaveCoord = conflictVoxels[sourceCoord];
                    NPVoxCoord nearbyCoord     = GetNearbyCoord(transformedModel, targetSaveCoord, resolveConflictMethod);
                    if (!nearbyCoord.Equals(NPVoxCoord.INVALID))
                    {
                        transformedModel.SetVoxel(nearbyCoord, sourceModel.GetVoxel(sourceCoord));
                        if (hasVoxelGroups)
                        {
                            transformedModel.SetVoxelGroup(nearbyCoord, sourceModel.GetVoxelGroup(sourceCoord));
                        }
                        if (hasBoneGropus)
                        {
                            transformedBoneModel.SetBoneMask(nearbyCoord, sourceBoneModel.GetBoneMask(sourceCoord));
                        }
                        numberOfConflictsSolved++;
                    }
                }
            }

            if (numberOfConflictsSolved != conflictVoxels.Count)
            {
                Debug.Log(string.Format("transformation has resolved {0}/{1} conflicting voxels", numberOfConflictsSolved, conflictVoxels.Count));
            }
        }

        // 4. transform all sockets
        NPVoxSocket[] sockets = new NPVoxSocket[sourceModel.Sockets.Length];
        for (int i = 0; i < sockets.Length; i++)
        {
            NPVoxSocket socket = sourceModel.Sockets[i];
            if (clampedBox.Contains(socket.Anchor))
            {
                // transform anchor
                Vector3 saveOriginalAnchor = NPVoxCoordUtil.ToVector(socket.Anchor);
                Vector3 saveTargetAnchor   = transformMatrix.MultiplyPoint(saveOriginalAnchor) + NPVoxCoordUtil.ToVector(offset);
                socket.Anchor = NPVoxCoordUtil.ToCoord(saveTargetAnchor);

                // transform Quaternion
                Quaternion originalRotation = Quaternion.Euler(socket.EulerAngles);
                Matrix4x4  rotated          = (Matrix4x4.TRS(Vector3.zero, originalRotation, Vector3.one) * transformMatrix);
                socket.EulerAngles = Matrix4x4Util.GetRotation(rotated).eulerAngles;
            }
            else
            {
                socket.Anchor = socket.Anchor + offset;
            }
            sockets[i] = socket;
        }
        transformedModel.Sockets = sockets;


        // 5. count all voxels
        transformedModel.NumVoxels = transformedModel.NumVoxels - (conflictVoxels.Count - numberOfConflictsSolved);
        transformedModel.RecalculateNumVoxels(true);
        return(transformedModel);
    }
예제 #15
0
    override protected NPVoxModel CreateProduct(NPVoxModel reuse = null)
    {
        if (Input == null)
        {
            return(NPVoxModel.NewInvalidInstance(reuse, "Input was null"));
        }
        NPVoxModel inputModel = ((NPVoxIModelFactory)Input).GetProduct();

        bool hasVoxelGroups = inputModel.HasVoxelGroups();

        if (AffectedArea.Equals(NPVoxBox.INVALID))
        {
            NPVoxModel model = NPVoxModel.NewInstance(inputModel, reuse);
            model.CopyOver(inputModel);
            return(model);
        }

        NPVoxBox clampedBox = inputModel.Clamp(AffectedArea);

        NPVoxModel transformedModel = null;

        transformedModel = NPVoxModel.NewInstance(inputModel, reuse);
        if (hasVoxelGroups)
        {
            transformedModel.InitVoxelGroups();
        }
        transformedModel.NumVoxelGroups = inputModel.NumVoxelGroups;
        transformedModel.NumVoxels      = inputModel.NumVoxels;
        transformedModel.Colortable     = inputModel.Colortable != null ? (Color32[])inputModel.Colortable.Clone() : null;
        transformedModel.Sockets        = inputModel.Sockets != null ? (NPVoxSocket[])inputModel.Sockets.Clone() : null;

        NPVoxBoneModel transformedBoneModel = transformedModel as NPVoxBoneModel;
        NPVoxBoneModel inputBoneModel       = inputModel as NPVoxBoneModel;
        bool           isBoneModel          = false;

        if (transformedBoneModel != null)
        {
            transformedBoneModel.AllBones = NPVoxBone.CloneBones(inputBoneModel.AllBones);
            isBoneModel = true;
        }

        byte brightenedColor = NPVoxModelUtils.FindUnusedColor(inputModel);

        if (brightenedColor == 0)
        {
            Debug.LogWarning("could not find a free color to brighten the model");
        }

        Color32 brightenColor32 = inputModel.Colortable[brightenedColor];

        foreach (NPVoxCoord coord in inputModel.EnumerateVoxels())
        {
            if (!isBoneModel)
            {
                if (clampedBox.Contains(coord) && brightenedColor != 0)
                {
                    brightenColor32 = inputModel.Colortable[inputModel.GetVoxel(coord)];
                    transformedModel.SetVoxel(coord, brightenedColor);
                }
                else
                {
                    transformedModel.SetVoxel(coord, inputModel.GetVoxel(coord));
                }
            }
            else
            {
                if (hiddenBonesMask == 0 || !inputBoneModel.IsInBoneMask(coord, hiddenBonesMask))
                {
                    if (clampedBox.Contains(coord) && brightenedColor != 0 && inputBoneModel.IsInBoneMask(coord, boneMask))
                    {
                        brightenColor32 = inputModel.Colortable[inputModel.GetVoxel(coord)];
                        transformedModel.SetVoxel(coord, brightenedColor);
                    }
                    else
                    {
                        transformedModel.SetVoxel(coord, inputModel.GetVoxel(coord));
                    }
                }
                transformedBoneModel.SetBoneMask(coord, inputBoneModel.GetBoneMask(coord));
            }

            if (hasVoxelGroups)
            {
                transformedModel.SetVoxelGroup(coord, inputModel.GetVoxelGroup(coord));
            }
        }

        if (brightenedColor != 0)
        {
            transformedModel.Colortable[brightenedColor] = NPVoxModelUtils.BrightenColor(brightenColor32);
        }


        transformedModel.RecalculateNumVoxels(true);
        return(transformedModel);
    }