Ejemplo n.º 1
0
        public apLinkedMatrix SetMatrixWrap(apMatrix matrixWrap, CALCULATE_TYPE calculateType, float lerpIfInterpolation = 1.0f)
        {
            _valueType = VALUE_TYPE.MatrixWrap;
            if (_matrixWrap == null)
            {
                _matrixWrap = new apMatrix(matrixWrap);
            }
            else
            {
                _matrixWrap.SetMatrix(matrixWrap);
            }
            _calculateType = calculateType;
            if (_calculateType == CALCULATE_TYPE.Interpolation)
            {
                _lerp = lerpIfInterpolation;
            }

            _weight   = 1.0f;
            _isWeight = false;

            _weightCalAdded   = 1.0f;
            _isWeightCalAdded = false;

            return(this);
        }
Ejemplo n.º 2
0
        public bool Bake(apModifiedBone srcModBone, apPortrait portrait)
        {
            _portrait         = portrait;
            _meshGroupID_Bone = srcModBone._meshGropuUniqueID_Bone;
            apOptTransform meshGroupTransform = portrait.GetOptTransformAsMeshGroup(_meshGroupID_Bone);

            if (meshGroupTransform == null)
            {
                Debug.LogError("[ModBone] Bake 실패 : 찾을 수 없는 OptTransform [" + _meshGroupID_Bone + "]");
                return(false);
            }

            _transformUniqueID = meshGroupTransform._transformID;
            _meshGroup_Bone    = meshGroupTransform;

            _boneID = srcModBone._boneID;

            _bone = meshGroupTransform.GetBone(_boneID);
            if (_bone == null)
            {
                Debug.LogError("[ModBone] Bake 실패 : 찾을 수 없는 Bone [" + _boneID + "]");
                return(false);
            }
            _transformMatrix = new apMatrix(srcModBone._transformMatrix);
            return(true);
        }
Ejemplo n.º 3
0
        public void Scale__MeshGroup_Setting(Vector2 deltaScaleW, bool isFirstScale)
        {
            if (Editor.Select.MeshGroup == null || !Editor.Select.IsMeshGroupSettingChangePivot)
            {
                return;
            }

            if (deltaScaleW.sqrMagnitude == 0.0f && !isFirstScale)
            {
                return;
            }

            apMatrix targetMatrix      = null;
            object   targetObj         = null;
            apMatrix worldMatrix       = null;
            apMatrix parentWorldMatrix = null;
            //Modifier가 적용이 안된 상태이므로
            //World Matrix = ParentWorld x ToParent(Default) 가 성립한다.

            bool isRootMeshGroup = false;

            if (Editor.Select.SubMeshInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshInGroup._matrix;
                targetObj         = Editor.Select.SubMeshInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshInGroup._matrix_TF_ParentWorld;

                isRootMeshGroup = Editor.Select.MeshGroup._childMeshTransforms.Contains(Editor.Select.SubMeshInGroup);
            }
            else if (Editor.Select.SubMeshGroupInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshGroupInGroup._matrix;
                targetObj         = Editor.Select.SubMeshGroupInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshGroupInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshGroupInGroup._matrix_TF_ParentWorld;

                isRootMeshGroup = false;
            }
            else
            {
                return;
            }
            worldMatrix._scale += deltaScaleW;
            worldMatrix.MakeMatrix();
            worldMatrix.RInverse(parentWorldMatrix);            //ParentWorld-1 x World = ToParent


            //Undo
            if (isFirstScale)
            {
                apEditorUtil.SetRecord_MeshGroup(apUndoGroupData.ACTION.MeshGroup_Gizmo_ScaleTransform, Editor, Editor.Select.MeshGroup, targetObj, false, !isRootMeshGroup);
            }

            //Vector2 scale2 = new Vector2(targetMatrix._scale.x, targetMatrix._scale.y);
            //targetMatrix.SetScale(deltaScaleW + scale2);
            targetMatrix.SetScale(worldMatrix._scale);
            targetMatrix.MakeMatrix();
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Parent의 Matrix를 추가한다. (Parent x This)
        /// </summary>
        /// <param name="matrix_parentTransform"></param>
        //public void AddWorldMatrix_Parent(apMatrix3x3 matrix_parentTransform)
        public void AddWorldMatrix_Parent(apMatrix matrix_parentTransform)
        {
            //_matrix_TF_Cal_Parent = matrix_parentTransform.MtrxToSpace * _matrix_TF_Cal_Parent;
            ////_calculateTmpMatrix.SRMultiply(matrix_parentTransform, true);
            ////_matrix_TF_Cal_ToWorld = _calculateTmpMatrix.MtrxToSpace;

            _matrix_TF_ParentWorld.SetMatrix(matrix_parentTransform);
        }
Ejemplo n.º 5
0
        public void Rotate__MeshGroup_Setting(float deltaAngleW)
        {
            if (Editor.Select.MeshGroup == null || !Editor.Select.IsMeshGroupSettingChangePivot)
            {
                return;
            }

            if (deltaAngleW == 0.0f)
            {
                return;
            }

            apMatrix targetMatrix      = null;
            object   targetObj         = null;
            apMatrix worldMatrix       = null;
            apMatrix parentWorldMatrix = null;

            if (Editor.Select.SubMeshInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshInGroup._matrix;
                targetObj         = Editor.Select.SubMeshInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshInGroup._matrix_TF_ParentWorld;
            }
            else if (Editor.Select.SubMeshGroupInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshGroupInGroup._matrix;
                targetObj         = Editor.Select.SubMeshGroupInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshGroupInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshGroupInGroup._matrix_TF_ParentWorld;
            }
            else
            {
                return;
            }

            float nextAngle = worldMatrix._angleDeg + deltaAngleW;

            while (nextAngle < -180.0f)
            {
                nextAngle += 360.0f;
            }
            while (nextAngle > 180.0f)
            {
                nextAngle -= 360.0f;
            }
            worldMatrix._angleDeg = nextAngle;
            worldMatrix.MakeMatrix();
            worldMatrix.RInverse(parentWorldMatrix);            //ParentWorld-1 x World = ToParent


            //Undo
            apEditorUtil.SetRecord(apUndoGroupData.ACTION.MeshGroup_Gizmo_RotateTransform, Editor.Select.MeshGroup, targetObj, false, Editor);

            //targetMatrix.SetRotate(deltaAngleW + targetMatrix._angleDeg);
            targetMatrix.SetRotate(worldMatrix._angleDeg);
            targetMatrix.MakeMatrix();
        }
Ejemplo n.º 6
0
        public void SetModifiedTransform(apMatrix matrix_modified)
        {
            ////_calculateTmpMatrix_Local.SRMultiply(matrix_modified, true);//Parent
            //_calculateTmpMatrix_Local.SRMultiply(matrix_modified, false);//Child

            //_matrix_TF_Cal_Local = _calculateTmpMatrix_Local.MtrxToSpace;

            _matrix_TF_LocalModified.SetMatrix(matrix_modified);
        }
Ejemplo n.º 7
0
        // Functions
        //---------------------------------------------------------
        // Keyframe -> File
        public void SetAnimKeyframe(int unitID, apAnimKeyframe animKeyframe)
        {
            _unitID = unitID;

            _keyframeUniqueID = animKeyframe._uniqueID;
            _linkedKeyframe   = animKeyframe;

            _frameIndex    = animKeyframe._frameIndex;
            _isKeyValueSet = animKeyframe._isKeyValueSet;

            _isActive = animKeyframe._isActive;

            _isLoopAsStart = animKeyframe._isLoopAsStart;
            _isLoopAsEnd   = animKeyframe._isLoopAsEnd;

            _loopFrameIndex = animKeyframe._loopFrameIndex;

            _activeFrameIndexMin = animKeyframe._activeFrameIndexMin;
            _activeFrameIndexMax = animKeyframe._activeFrameIndexMax;

            _activeFrameIndexMin_Dummy = animKeyframe._activeFrameIndexMin_Dummy;
            _activeFrameIndexMax_Dummy = animKeyframe._activeFrameIndexMax_Dummy;

            //Curve 정보
            _curve_PrevTangentType = animKeyframe._curveKey._prevTangentType;
            _curve_PrevSmoothX     = animKeyframe._curveKey._prevSmoothX;
            _curve_PrevSmoothY     = animKeyframe._curveKey._prevSmoothY;
            _curve_NextTangentType = animKeyframe._curveKey._nextTangentType;
            _curve_NextSmoothX     = animKeyframe._curveKey._nextSmoothX;
            _curve_NextSmoothY     = animKeyframe._curveKey._nextSmoothY;

            //Control Param 타입이면
            //Control Param의 어떤 값에 동기화되는가
            _conSyncValue_Int     = animKeyframe._conSyncValue_Int;
            _conSyncValue_Float   = animKeyframe._conSyncValue_Float;
            _conSyncValue_Vector2 = animKeyframe._conSyncValue_Vector2;

            //Modifier Mesh 타입일때
            _isModMeshType = animKeyframe._linkedModMesh_Editor != null;
            _isModBoneType = animKeyframe._linkedModBone_Editor != null;

            //>> Transform만 저장한다.
            _modTransformMatrix = new apMatrix();
            _modMeshColor       = Color.black;
            _modVisible         = true;

            if (_isModMeshType)
            {
                _modTransformMatrix.SetMatrix(animKeyframe._linkedModMesh_Editor._transformMatrix);
                _modMeshColor = animKeyframe._linkedModMesh_Editor._meshColor;
                _modVisible   = animKeyframe._linkedModMesh_Editor._isVisible;
            }
            else if (_isModBoneType)
            {
                _modTransformMatrix.SetMatrix(animKeyframe._linkedModBone_Editor._transformMatrix);
            }
        }
        // Editor Functions
        //------------------------------------------------
        public void Bake(apPortrait portrait,         //apMeshGroup srcMeshGroup,
                         apOptTransform parentTransform,
                         apOptRootUnit rootUnit,
                         string name,
                         int transformID, int meshGroupUniqueID, apMatrix defaultMatrix,
                         bool isMesh, int level, int depth,
                         bool isVisible_Default,
                         Color meshColor2X_Default,
                         float zScale
                         )
        {
            _portrait          = portrait;
            _rootUnit          = rootUnit;
            _transformID       = transformID;
            _name              = name;
            _meshGroupUniqueID = meshGroupUniqueID;

            _parentTransform = parentTransform;

            _defaultMatrix = new apMatrix(defaultMatrix);
            _transform     = transform;

            _level = level;
            _depth = depth;

            _isVisible_Default   = isVisible_Default;
            _meshColor2X_Default = meshColor2X_Default;

            if (parentTransform != null)
            {
                _depth -= parentTransform._depth;
            }

            //이부분 실험 중
            //1. Default Matrix를 Transform에 적용하고, Modifier 계산에서는 제외하는 경우
            //결과 : Bake시에는 "Preview"를 위해서 DefaultMatrix 위치로 이동을 시키지만, 실행시에는 원점으로 이동시킨다.
            //_transform.localPosition = _defaultMatrix.Pos3 - new Vector3(0.0f, 0.0f, (float)_depth);
            //_transform.localRotation = Quaternion.Euler(0.0f, 0.0f, _defaultMatrix._angleDeg);
            //_transform.localScale = _defaultMatrix._scale;

            //2. Default Matrix를 Modifier에 포함시키고 Transform은 원점인 경우 (Editor와 동일)
            _transform.localPosition = -new Vector3(0.0f, 0.0f, (float)_depth * zScale);
            _transform.localRotation = Quaternion.identity;
            _transform.localScale    = Vector3.one;

            if (isMesh)
            {
                _unitType = UNIT_TYPE.Mesh;
            }
            else
            {
                _unitType = UNIT_TYPE.Group;
            }

            _childTransforms = null;
            _childMesh       = null;
        }
Ejemplo n.º 9
0
        // Functions
        //--------------------------------------------
        public void ReadyToCalculate()
        {
            _matrix.MakeMatrix();

            //변경
            //[Parent World x To Parent x Local TF] 조합으로 변경

            if (_matrix_TF_ParentWorld == null)
            {
                _matrix_TF_ParentWorld = new apMatrix();
            }
            if (_matrix_TF_ParentWorldWithoutMod == null)
            {
                _matrix_TF_ParentWorldWithoutMod = new apMatrix();
            }
            if (_matrix_TF_ToParent == null)
            {
                _matrix_TF_ToParent = new apMatrix();
            }
            if (_matrix_TF_LocalModified == null)
            {
                _matrix_TF_LocalModified = new apMatrix();
            }
            if (_matrix_TFResult_World == null)
            {
                _matrix_TFResult_World = new apMatrix();
            }
            if (_matrix_TFResult_WorldWithoutMod == null)
            {
                _matrix_TFResult_WorldWithoutMod = new apMatrix();
            }
            if (_invMatrix_TFResult_World == null)
            {
                _invMatrix_TFResult_World = new apMatrix();
            }
            if (_invMatrix_TFResult_WorldWithoutMod == null)
            {
                _invMatrix_TFResult_WorldWithoutMod = new apMatrix();
            }


            _matrix_TF_ParentWorld.SetIdentity();
            _matrix_TF_ParentWorldWithoutMod.SetIdentity();
            _matrix_TF_ToParent.SetIdentity();
            _matrix_TF_LocalModified.SetIdentity();

            //ToParent는 Pivot이므로 고정
            _matrix_TF_ToParent.SetMatrix(_matrix);

            _matrix_TFResult_World.SetIdentity();
            _matrix_TFResult_WorldWithoutMod.SetIdentity();
            _invMatrix_TFResult_World.SetIdentity();
            _invMatrix_TFResult_WorldWithoutMod.SetIdentity();

            CalculatedLog.ReadyToRecord();
        }
Ejemplo n.º 10
0
        public override bool Save(object target, string strParam)
        {
            base.Save(target, strParam);

            apAnimKeyframe keyframe = target as apAnimKeyframe;

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

            _key_TimelineLayer = keyframe._parentTimelineLayer;
            if (_key_TimelineLayer == null)
            {
                return(false);
            }

            _animCurve     = new apAnimCurve(keyframe._curveKey, keyframe._frameIndex);
            _isKeyValueSet = keyframe._isKeyValueSet;

            //_conSyncValue_Bool = keyframe._conSyncValue_Bool;
            _conSyncValue_Int     = keyframe._conSyncValue_Int;
            _conSyncValue_Float   = keyframe._conSyncValue_Float;
            _conSyncValue_Vector2 = keyframe._conSyncValue_Vector2;
            //_conSyncValue_Vector3 = keyframe._conSyncValue_Vector3;
            //_conSyncValue_Color = keyframe._conSyncValue_Color;

            _vertices.Clear();
            _transformMatrix = new apMatrix();
            _meshColor       = new Color(0.5f, 0.5f, 0.5f, 1.0f);
            _isVisible       = true;

            if (keyframe._linkedModMesh_Editor != null)
            {
                apModifiedMesh modMesh = keyframe._linkedModMesh_Editor;
                _vertices.Clear();
                int nVert = modMesh._vertices.Count;

                for (int i = 0; i < nVert; i++)
                {
                    apModifiedVertex modVert = modMesh._vertices[i];
                    _vertices.Add(new VertData(modVert._vertex, modVert._deltaPos));
                }

                _transformMatrix = new apMatrix(modMesh._transformMatrix);
                _meshColor       = modMesh._meshColor;
                _isVisible       = modMesh._isVisible;
            }
            else if (keyframe._linkedModBone_Editor != null)
            {
                apModifiedBone modBone = keyframe._linkedModBone_Editor;

                _transformMatrix = new apMatrix(modBone._transformMatrix);
            }
            return(true);
        }
Ejemplo n.º 11
0
        public void BlendMatrix_Add(apMatrix curMatrix, apMatrix itpLayer, float itpWeight)
        {
            curMatrix._pos      += itpLayer._pos * itpWeight;
            curMatrix._angleDeg += itpLayer._angleDeg * itpWeight;

            //Scale은 Multiply의 보간 방식
            curMatrix._scale.x = (curMatrix._scale.x * (1.0f - itpWeight)) + (curMatrix._scale.x * itpLayer._scale.x * itpWeight);
            curMatrix._scale.y = (curMatrix._scale.y * (1.0f - itpWeight)) + (curMatrix._scale.y * itpLayer._scale.y * itpWeight);
            //curMatrix._scale.z = (curMatrix._scale.z * (1.0f - itpWeight)) + (curMatrix._scale.z * itpLayer._scale.z * itpWeight);
        }
        private void BlendMatrix_Add(apMatrix prevResult, apMatrix nextResult, float nextWeight)
        {
            prevResult._pos      += nextResult._pos * nextWeight;
            prevResult._angleDeg += nextResult._angleDeg * nextWeight;
            //prevResult._scale += nextResult._scale * nextWeight;

            prevResult._scale.x = (prevResult._scale.x * (1.0f - nextWeight)) + (prevResult._scale.x * nextResult._scale.x * nextWeight);
            prevResult._scale.y = (prevResult._scale.y * (1.0f - nextWeight)) + (prevResult._scale.y * nextResult._scale.y * nextWeight);
            //prevResult._scale.z = (prevResult._scale.z * (1.0f - nextWeight)) + (prevResult._scale.z * nextResult._scale.z * nextWeight);
        }
Ejemplo n.º 13
0
        public void Bake_Transform(apMatrix transformMatrix)
        {
            _dataType |= DATA_TYPE.Transform;

            _subModMesh_Transform    = new apOptModifiedMesh_Transform[1];
            _subModMesh_Transform[0] = new apOptModifiedMesh_Transform();
            apOptModifiedMesh_Transform subMod_Transform = _subModMesh_Transform[0];

            subMod_Transform.Bake(transformMatrix);
        }
Ejemplo n.º 14
0
        public void Move__MeshGroup_Setting(Vector2 curMouseGL, Vector2 curMousePosW, Vector2 deltaMoveW, int btnIndex, bool isFirstMove)
        {
            if (Editor.Select.MeshGroup == null || !Editor.Select.IsMeshGroupSettingChangePivot)
            {
                return;
            }

            if (deltaMoveW.sqrMagnitude == 0.0f)
            {
                return;
            }

            apMatrix targetMatrix      = null;
            object   targetObj         = null;
            apMatrix worldMatrix       = null;
            apMatrix parentWorldMatrix = null;

            //Modifier가 적용이 안된 상태이므로
            //World Matrix = ParentWorld x ToParent(Default) 가 성립한다.
            if (Editor.Select.SubMeshInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshInGroup._matrix;           //=ToParent
                targetObj         = Editor.Select.SubMeshInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshInGroup._matrix_TF_ParentWorld;
            }
            else if (Editor.Select.SubMeshGroupInGroup != null)
            {
                targetMatrix      = Editor.Select.SubMeshGroupInGroup._matrix;           //=ToParent
                targetObj         = Editor.Select.SubMeshGroupInGroup;
                worldMatrix       = new apMatrix(Editor.Select.SubMeshGroupInGroup._matrix_TFResult_World);
                parentWorldMatrix = Editor.Select.SubMeshGroupInGroup._matrix_TF_ParentWorld;
            }
            else
            {
                return;
            }

            worldMatrix._pos += deltaMoveW;
            worldMatrix.MakeMatrix();
            worldMatrix.RInverse(parentWorldMatrix);            //ParentWorld-1 x World = ToParent


            Vector2 newLocalPos = worldMatrix._pos;


            //Undo
            apEditorUtil.SetRecord(apUndoGroupData.ACTION.MeshGroup_Gizmo_MoveTransform, Editor.Select.MeshGroup, targetObj, false, Editor);

            //targetMatrix.SetPos(targetMatrix._pos.x + deltaMoveW.x, targetMatrix._pos.y + deltaMoveW.y);
            targetMatrix.SetPos(newLocalPos.x, newLocalPos.y);
            targetMatrix.MakeMatrix();

            //Editor.RefreshControllerAndHierarchy();
        }
Ejemplo n.º 15
0
        public void TransformChanged_Position__MeshGroup_Setting(Vector2 pos, int depth)
        {
            if (Editor.Select.MeshGroup == null || !Editor.Select.IsMeshGroupSettingChangePivot)
            {
                return;
            }

            if (Editor.Select.SubMeshInGroup == null && Editor.Select.SubMeshGroupInGroup == null)
            {
                return;
            }

            apRenderUnit curRenderUnit  = null;
            apMatrix     curMatrixParam = null;

            object targetObj = null;

            if (Editor.Select.SubMeshInGroup != null)
            {
                curRenderUnit  = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.SubMeshInGroup);
                curMatrixParam = Editor.Select.SubMeshInGroup._matrix;
                targetObj      = Editor.Select.SubMeshInGroup;
            }
            else if (Editor.Select.SubMeshGroupInGroup != null)
            {
                curRenderUnit  = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.SubMeshGroupInGroup);
                curMatrixParam = Editor.Select.SubMeshGroupInGroup._matrix;
                targetObj      = Editor.Select.SubMeshGroupInGroup;
            }

            if (curRenderUnit == null)
            {
                return;
            }

            //Undo
            apEditorUtil.SetRecord(apUndoGroupData.ACTION.MeshGroup_Gizmo_MoveTransform, Editor.Select.MeshGroup, targetObj, false, Editor);

            bool bSort = false;

            if (curRenderUnit.GetDepth() != depth)
            {
                //curRenderUnit.SetDepth(depth);
                Editor.Select.MeshGroup.ChangeRenderUnitDetph(curRenderUnit, depth);

                bSort = true;
            }
            curMatrixParam.SetPos(pos);
            curMatrixParam.MakeMatrix();
            if (bSort)
            {
                Editor.Select.MeshGroup.SortRenderUnits(true);
            }
            Editor.SetRepaint();
        }
Ejemplo n.º 16
0
        // Functions
        //--------------------------------------------
        public void ReadyToCalculate()
        {
            _matrix.MakeMatrix();

            //_matrix_TF_Cal_Parent = apMatrix3x3.identity;
            //_matrix_TF_Cal_Local = _matrix.MtrxToSpace;

            //if(_calculateTmpMatrix == null)
            //{
            //	_calculateTmpMatrix = new apMatrix();
            //}
            //_calculateTmpMatrix.SetIdentity();
            //_calculateTmpMatrix.SetMatrix(_matrix);

            //if(_calculateTmpMatrix_Local == null)
            //{
            //	_calculateTmpMatrix_Local = new apMatrix();
            //}
            //_calculateTmpMatrix_Local.SetIdentity();
            //_calculateTmpMatrix_Local.SetMatrix(_matrix);

            //변경
            //[Parent World x To Parent x Local TF] 조합으로 변경

            if (_matrix_TF_ParentWorld == null)
            {
                _matrix_TF_ParentWorld = new apMatrix();
            }
            if (_matrix_TF_ToParent == null)
            {
                _matrix_TF_ToParent = new apMatrix();
            }
            if (_matrix_TF_LocalModified == null)
            {
                _matrix_TF_LocalModified = new apMatrix();
            }
            if (_matrix_TFResult_World == null)
            {
                _matrix_TFResult_World = new apMatrix();
            }
            if (_matrix_TFResult_WorldWithoutMod == null)
            {
                _matrix_TFResult_WorldWithoutMod = new apMatrix();
            }

            _matrix_TF_ParentWorld.SetIdentity();
            _matrix_TF_ToParent.SetIdentity();
            _matrix_TF_LocalModified.SetIdentity();

            //ToParent는 Pivot이므로 고정
            _matrix_TF_ToParent.SetMatrix(_matrix);

            _matrix_TFResult_World.SetIdentity();
            _matrix_TFResult_WorldWithoutMod.SetIdentity();
        }
Ejemplo n.º 17
0
        public override bool Save(object target, string strParam)
        {
            base.Save(target, strParam);

            apModifiedMesh modMesh = target as apModifiedMesh;

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

            _key_MeshGroupOfMod       = modMesh._meshGroupOfModifier;
            _key_MeshGroupOfTransform = modMesh._meshGroupOfTransform;

            _key_MeshTransform      = null;
            _key_MeshGroupTransform = null;
            _key_RenderUnit         = null;

            if (modMesh._transform_Mesh != null)
            {
                _key_MeshTransform = modMesh._transform_Mesh;
            }
            if (modMesh._transform_MeshGroup != null)
            {
                _key_MeshGroupTransform = modMesh._transform_MeshGroup;
            }
            _key_RenderUnit = modMesh._renderUnit;

            _vertices.Clear();
            int nVert = modMesh._vertices.Count;

            for (int i = 0; i < nVert; i++)
            {
                apModifiedVertex modVert = modMesh._vertices[i];
                _vertices.Add(new VertData(modVert._vertex, modVert._deltaPos));
            }

            _transformMatrix = new apMatrix(modMesh._transformMatrix);
            _meshColor       = modMesh._meshColor;
            _isVisible       = modMesh._isVisible;


            _isExtraValueEnabled = false;
            _extraValue          = null;

            //추가 3.29 : ExtraValue도 복사
            if (modMesh._isExtraValueEnabled)
            {
                _isExtraValueEnabled = true;
                _extraValue          = new ExtraDummyValue(modMesh._extraValue);
            }

            return(true);
        }
Ejemplo n.º 18
0
        /// <summary>
        /// 변형된 modMatrix에 대해서 StackLayer, CalParamResult, ParamSet 상에서 레이어 보간된 연산을 역으로 수행하여
        /// 요청된 Target Modified Matrix 레벨에서 어떤 값을 가져야 하는지 리턴한다.
        /// [Matrix에 대한 역 보간처리 함수]
        /// </summary>
        /// <param name="targetModifiedLog"></param>
        /// <param name="layer_ParamSetGroupLog"></param>
        /// <param name="layer_CalParamResultLog"></param>
        /// <param name="stackLayer_MeshTransformLog"></param>
        /// <param name="modMatrix_next"></param>
        /// <returns></returns>
        private apMatrix GetInverseInterpolatedMatrix(apCalculatedLog layer_ParamSetGroupLog,
                                                      apCalculatedLog layer_CalParamResultLog,
                                                      apCalculatedLog stackLayer_MeshTransformLog,
                                                      apMatrix modMatrix_next
                                                      )
        {
            //1. StackLayer -> CalParamResultLog
            if (!stackLayer_MeshTransformLog._childCalParamResultLogs.Contains(layer_CalParamResultLog))
            {
                return(null);
            }

            //Debug.Log("GetInvMatrix");
            //for (int i = 0; i < stackLayer_MeshTransformLog._childCalParamResultLogs.Count; i++)
            //{
            //	Debug.Log("Cal Param [" + i + "] : " + stackLayer_MeshTransformLog._childCalParamResultLogs[i]._calResultParam._linkedModifier.DisplayName + " / "
            //		+ stackLayer_MeshTransformLog._childCalParamResultLogs[i]._layerBlendType + " (" + stackLayer_MeshTransformLog._childCalParamResultLogs[i]._weight + ")");

            //}
            //for (int i = 0; i < layer_CalParamResultLog._childLayerLogs.Count; i++)
            //{
            //	Debug.Log("ParamSetGroup [" + i + "] : " + layer_CalParamResultLog._childLayerLogs[i]._paramSetGroup._keyControlParam._keyName + " / "
            //		+ layer_CalParamResultLog._childLayerLogs[i]._layerBlendType + " ( " + layer_CalParamResultLog._childLayerLogs[i]._weight + ")"
            //		+ "\r\n" + layer_CalParamResultLog._childLayerLogs[i]._paramSetGroup._tmpMatrix);

            //}


            //1. StackLayer -> CalParamResultLog
            apMatrix modMatrix_CalParamResultLog = GetSubInverseLayeredMatrix(layer_CalParamResultLog, stackLayer_MeshTransformLog, modMatrix_next);

            if (modMatrix_CalParamResultLog == null)
            {
                Debug.LogError("GetInverseInterpolatedMatrix 실패 : StackLayer -> CalParamResultLog를 처리할 수 없다.");
                return(null);
            }
            //Debug.Log("Calculate : 1. StackLayer -> CalParamResultLog\r\n" + modMatrix_next + "\r\n >>>> \r\n" + modMatrix_CalParamResultLog);


            //2. CalParamResultLog -> ParamSetGroupLog (ParamSet은 하나만 선택했으니 ParamSet 레벨과 동일하다)
            apMatrix modMatrix_ParamSetGroupLog = GetSubInverseLayeredMatrix(layer_ParamSetGroupLog, layer_CalParamResultLog, modMatrix_CalParamResultLog);

            if (modMatrix_ParamSetGroupLog == null)
            {
                Debug.LogError("GetInverseInterpolatedMatrix 실패 : StackLayer -> CalParamResultLog를 처리할 수 없다.");
                return(null);
            }

            //Debug.Log("Calculate : 2. CalParamResultLog -> ParamSetGroupLog\r\n" + modMatrix_CalParamResultLog + "\r\n >>>> \r\n" + modMatrix_ParamSetGroupLog);


            return(modMatrix_ParamSetGroupLog);
        }
Ejemplo n.º 19
0
        public void Bake_MeshGroupTransform(apOptTransform rootTransform, apOptTransform targetTransform,
                                            apMatrix transformMatrix, Color meshColor, bool isVisible)
        {
            //_targetType = apModifiedMesh.TARGET_TYPE.MeshGroupTransformOnly;

            _rootTransform   = rootTransform;
            _targetTransform = targetTransform;

            _transformMatrix = new apMatrix(transformMatrix);

            _meshColor = meshColor;
            _isVisible = isVisible;
        }
Ejemplo n.º 20
0
            public ParamKeyValueSet(apModifierParamSetGroup keyParamSetGroup, apModifierParamSet paramSet, apModifiedBone modifiedValue)
            {
                _keyParamSetGroup = keyParamSetGroup;
                _paramSet         = paramSet;
                _modifiedMesh     = null;
                _modifiedBone     = modifiedValue;
                _layerIndx        = _paramSet._parentParamSetGroup._layerIndex;

                //추가 : RotationBias
                _isAnimRotationBias         = false;
                _animRotationBiasAngle      = 0;
                _animRotationBiasAngle_Prev = -1;
                _animRotationBiasedMatrix   = new apMatrix();
            }
Ejemplo n.º 21
0
            /// <summary>
            /// Keyframe에 Rotation Bias 설정이 있는 경우 관련 변수를 갱신한다.
            /// </summary>
            /// <param name="rotationBias"></param>
            /// <param name="rotationCount"></param>
            public void SetAnimRotationBias(apAnimKeyframe.ROTATION_BIAS rotationBias, int rotationCount)
            {
                if (rotationBias == apAnimKeyframe.ROTATION_BIAS.CW)
                {
                    _isAnimRotationBias    = true;
                    _animRotationBiasAngle = -360 * rotationCount;
                }
                else if (rotationBias == apAnimKeyframe.ROTATION_BIAS.CCW)
                {
                    _isAnimRotationBias    = true;
                    _animRotationBiasAngle = 360 * rotationCount;
                }
                else
                {
                    _isAnimRotationBias    = false;
                    _animRotationBiasAngle = 0;
                }
                //에디터에서는 최적화가 아니라 언제 바뀔지 모르므로 항상 갱신
                //if(_animRotationBiasAngle_Prev != _animRotationBiasAngle && _isAnimRotationBias)
                if (_isAnimRotationBias)
                {
                    if (_animRotationBiasedMatrix == null)
                    {
                        _animRotationBiasedMatrix = new apMatrix();
                    }

                    if (_modifiedMesh != null)
                    {
                        _animRotationBiasedMatrix.SetTRS(
                            _modifiedMesh._transformMatrix._pos,
                            _modifiedMesh._transformMatrix._angleDeg + _animRotationBiasAngle,
                            _modifiedMesh._transformMatrix._scale
                            );
                    }
                    else if (_modifiedBone != null)
                    {
                        _animRotationBiasedMatrix.SetTRS(
                            _modifiedBone._transformMatrix._pos,
                            _modifiedBone._transformMatrix._angleDeg + _animRotationBiasAngle,
                            _modifiedBone._transformMatrix._scale
                            );
                    }
                    else
                    {
                        _animRotationBiasedMatrix.SetIdentity();
                    }

                    _animRotationBiasAngle_Prev = _animRotationBiasAngle;
                }
            }
Ejemplo n.º 22
0
            /// <summary>
            /// ModMesh와 연동되는 ParamKeyValue 생성
            /// </summary>
            public OptParamKeyValueSet(apOptParamSetGroup keyParamSetGroup, apOptParamSet paramSet, apOptModifiedMesh modifiedMesh)
            {
                _keyParamSetGroup = keyParamSetGroup;
                _paramSet         = paramSet;
                _modifiedMesh     = modifiedMesh;
                _layerIndex       = _keyParamSetGroup._layerIndex;

                _modifiedBone = null;

                //추가 : RotationBias
                _isAnimRotationBias         = false;
                _animRotationBiasAngle      = 0;
                _animRotationBiasAngle_Prev = -1;
                _animRotationBiasedMatrix   = new apMatrix();
            }
Ejemplo n.º 23
0
 public void SetMatrixWrap(apMatrix matrixWrap, CalculateType calculateType, bool isWeighted, float weight)
 {
     _valueType = UnitValueType.MatrixWrap;
     if (_val_MatrixWrap == null)
     {
         _val_MatrixWrap = new apMatrix(matrixWrap);                    //<<복사를 하자
     }
     else
     {
         _val_MatrixWrap.SetMatrix(matrixWrap);
     }
     _calculateType = calculateType;
     _isWeighted    = isWeighted;
     _weight        = weight;
 }
Ejemplo n.º 24
0
        public void LinkPortrait(apPortrait portrait, apModifierBase parentModifier)
        {
            _portrait       = portrait;
            _parentModifier = parentModifier;

            if (_tmpMatrix == null)
            {
                _tmpMatrix = new apMatrix();
            }

            if (_tmpPositions == null)
            {
                _tmpPositions = new List <Vector2>();
            }
        }
        //private void BlendMatrix_ITP(apMatrix prevResult, apMatrix nextResult, float prevWeight, float nextWeight)
        private void BlendMatrix_ITP(apMatrix prevResult, apMatrix nextResult, float nextWeight)
        {
            //prevResult._pos = ((prevResult._pos * prevWeight) + (nextResult._pos * nextWeight)) / (prevWeight + nextWeight);
            //prevResult._angleDeg = ((prevResult._angleDeg * prevWeight) + (nextResult._angleDeg * nextWeight)) / (prevWeight + nextWeight);
            //prevResult._scale = ((prevResult._scale * prevWeight) + (nextResult._scale * nextWeight)) / (prevWeight + nextWeight);

            //float totalWeight = prevWeight + nextWeight;
            //if(totalWeight <= 0.0f)
            //{
            //	return;
            //}

            //float totalWeight = 1.0f;

            //prevResult.LerpMartix(nextResult, nextWeight / totalWeight);
            prevResult.LerpMartix(nextResult, nextWeight);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// BlendMatrix_Add의 역연산 [ (curMatrix - subtractedLayer * weight) ]
        /// </summary>
        /// <param name="curMatrix"></param>
        /// <param name="subtractedLayer"></param>
        /// <param name="weight"></param>
        public void InverseBlendMatrix_Add(apMatrix curMatrix, apMatrix subtractedLayer, float weight)
        {
            if (weight <= 0.0f)
            {
                //처리하지 않는다.
                return;
            }

            //curMatrix._pos = curMatrix._pos + itpLayer._pos * itpWeight;
            //Result = Prev + Next * Weight
            //Prev = Result - (Next * Weight)

            curMatrix._pos      = curMatrix._pos - subtractedLayer._pos * weight;
            curMatrix._angleDeg = curMatrix._angleDeg - subtractedLayer._angleDeg * weight;

            //curMatrix._scale.x = (curMatrix._scale.x * (1.0f - itpWeight)) + (curMatrix._scale.x * itpLayer._scale.x * itpWeight);
            //Result = Prev * (1 - Weight) + (Prev * Next * Weight)
            //Result = Prev * (1 - Weight + Next * Weight)
            //Prev = Result / ((1 - Weight) + Next * Weight)
            float divScaleX = (1.0f - weight) + subtractedLayer._scale.x * weight;
            float divScaleY = (1.0f - weight) + subtractedLayer._scale.y * weight;

            //float divScaleZ = (1.0f - weight) + subtractedLayer._scale.z * weight;

            if (divScaleX == 0.0f)
            {
                curMatrix._scale.x = 0.0f;
            }
            else
            {
                curMatrix._scale.x = curMatrix._scale.x / divScaleX;
            }

            if (divScaleY == 0.0f)
            {
                curMatrix._scale.y = 0.0f;
            }
            else
            {
                curMatrix._scale.y = curMatrix._scale.y / divScaleY;
            }

            //if(divScaleZ == 0.0f)	{ curMatrix._scale.z = 0.0f; }
            //else					{ curMatrix._scale.z = curMatrix._scale.z / divScaleZ; }
        }
Ejemplo n.º 27
0
        public void TransformChanged_Position__MeshGroup_Setting(Vector2 pos)
        {
            if (Editor.Select.MeshGroup == null || !Editor.Select.IsMeshGroupSettingChangePivot)
            {
                return;
            }

            if (Editor.Select.SubMeshInGroup == null && Editor.Select.SubMeshGroupInGroup == null)
            {
                return;
            }

            apRenderUnit curRenderUnit  = null;
            apMatrix     curMatrixParam = null;

            object targetObj = null;

            if (Editor.Select.SubMeshInGroup != null)
            {
                curRenderUnit  = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.SubMeshInGroup);
                curMatrixParam = Editor.Select.SubMeshInGroup._matrix;
                targetObj      = Editor.Select.SubMeshInGroup;
            }
            else if (Editor.Select.SubMeshGroupInGroup != null)
            {
                curRenderUnit  = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.SubMeshGroupInGroup);
                curMatrixParam = Editor.Select.SubMeshGroupInGroup._matrix;
                targetObj      = Editor.Select.SubMeshGroupInGroup;
            }

            if (curRenderUnit == null)
            {
                return;
            }

            //Undo
            apEditorUtil.SetRecord_MeshGroup(apUndoGroupData.ACTION.MeshGroup_Gizmo_MoveTransform, Editor, Editor.Select.MeshGroup, targetObj, false, true);

            curMatrixParam.SetPos(pos);
            curMatrixParam.MakeMatrix();
            Editor.SetRepaint();
        }
Ejemplo n.º 28
0
        public void LinkPortrait(apPortrait portrait, apModifierBase parentModifier)
        {
            _portrait       = portrait;
            _parentModifier = parentModifier;

            if (_tmpMatrix == null)
            {
                _tmpMatrix = new apMatrix();
            }

            //if (_tmpPositions == null)
            //{
            //	_tmpPositions = new List<Vector2>();
            //}

            //if(_tmpVertMatrices == null)
            //{
            //	_tmpVertMatrices = new List<apMatrix3x3>();
            //}
        }
Ejemplo n.º 29
0
        /// <summary>
        /// BlendMatrix_Add의 역연산 중 TargetLayer에서 최종 결과값을 만드는 과정.
        /// Pos/Angle : [ X = (inverseUpperLayer - lowerLayer) / weight ]
        /// Scale : [ X = ( (inverseUpperLayer / lowerLayer) - 1 + weight ) / weight ]
        /// weight가 0이면 Null리턴
        /// </summary>
        /// <param name="curMatrix"></param>
        /// <param name="subtractedLayer"></param>
        /// <param name="weight"></param>
        public apMatrix InverseBlendMatrixTarget_Add(apMatrix invUpperLayerResult, apMatrix lowerLayerResult, apMatrix targetLayer, float weight)
        {
            if (weight <= 0.0f)
            {
                //처리하지 않는다.
                return(null);
            }

            apMatrix result = new apMatrix();

            result._pos.x    = (invUpperLayerResult._pos.x - lowerLayerResult._pos.x) / weight;
            result._pos.y    = (invUpperLayerResult._pos.y - lowerLayerResult._pos.y) / weight;
            result._angleDeg = (invUpperLayerResult._angleDeg - lowerLayerResult._angleDeg) / weight;

            result._scale.x = ((invUpperLayerResult._scale.x / lowerLayerResult._scale.x) - (1.0f - weight)) / weight;
            result._scale.y = ((invUpperLayerResult._scale.y / lowerLayerResult._scale.y) - (1.0f - weight)) / weight;
            //result._scale.z = ((invUpperLayerResult._scale.z / lowerLayerResult._scale.z) - (1.0f - weight)) / weight;

            return(result);
        }
Ejemplo n.º 30
0
        /// <summary>
        /// BlendMatrix_ITP의 역연산 중 TargetLayer에서 최종 결과값을 만드는 과정.
        /// [ X = (inverseUpperLayer - (lowerLayer * (1 - weight))) / (weight) ]
        /// weight가 0이면 Null 리턴
        /// </summary>
        /// <param name="curMatrix"></param>
        /// <param name="subtractedLayer"></param>
        /// <param name="weight"></param>
        public apMatrix InverseBlendMatrixTarget_ITP(apMatrix invUpperLayerResult, apMatrix lowerLayerResult, apMatrix targetLayer, float weight)
        {
            if (weight <= 0.0f)
            {
                return(null);
            }

            // ( InvUpperLayer - (lowerLayer * (1-weight)) ) / weight
            apMatrix result = new apMatrix();

            result._pos.x = (invUpperLayerResult._pos.x - lowerLayerResult._pos.x * (1.0f - weight)) / weight;
            result._pos.y = (invUpperLayerResult._pos.y - lowerLayerResult._pos.y * (1.0f - weight)) / weight;

            result._angleDeg = (invUpperLayerResult._angleDeg - lowerLayerResult._angleDeg * (1.0f - weight)) / weight;

            result._scale.x = (invUpperLayerResult._scale.x - lowerLayerResult._scale.x * (1.0f - weight)) / weight;
            result._scale.y = (invUpperLayerResult._scale.y - lowerLayerResult._scale.y * (1.0f - weight)) / weight;
            //result._scale.z = (invUpperLayerResult._scale.z - lowerLayerResult._scale.z * (1.0f - weight)) / weight;

            result.MakeMatrix();

            return(result);
        }