コード例 #1
0
        /// <summary>
        /// IMotionProviderメンバーの実装
        /// </summary>
        public void モーションを1フレーム進める(int fps, float elapsedTime, モーフ管理 morphManager)
        {
            // 行列の更新
            foreach (var boneMotion in boneMotions)
            {
                boneMotion.ReviseBone((ulong)現在のフレーム);
            }
            foreach (var morphMotion in morphMotions)
            {
                morphManager.進捗率を設定する(morphMotion.指定したフレームにおけるモーフ値を取得する((ulong)現在のフレーム), morphMotion.モーフ名);
            }

            // 停止中はフレームを進めない
            if (!isPlaying)
            {
                return;
            }

            // フレームを進める
            現在のフレーム += elapsedTime * fps;
            FrameTicked?.Invoke(this, new EventArgs());

            // 最終フレームに達した時の処理
            if (現在のフレーム >= このモーションにおける最終フレーム)
            {
                現在のフレーム = (actionAfterMotion == モーション再生終了後の挙動.Replay) ? 1.0e-3f : このモーションにおける最終フレーム;
                モーションが終了した?.Invoke(this, actionAfterMotion);
            }
        }
コード例 #2
0
        public void 初期化する(PMXモデル model, モーフ管理 morph, スキニング skinning, バッファ管理 bufferManager)
        {
            _スキニング = skinning;

            _Stopwatch = new Stopwatch();
            _Stopwatch.Start();

            _モーフ管理 = morph;

            モーションリスト = new List <KeyValuePair <string, モーション> >();
        }
コード例 #3
0
        public void モデルを初期化する()
        {
            var sw = new Stopwatch();

            sw.Start();   // 読み込み時間の計測開始

            if (!_初期化済み)
            {
                // PMXファイルからのPMXモデルの読み込み → しない

                // シェーダーの読み込み

                トゥーン管理.初期化する(サブリソースローダー);

                サブセット管理.初期化する(トゥーン管理, サブリソースローダー);

                エフェクト管理 = エフェクト管理を初期化して返す();


                // 定数バッファ

                バッファ管理を初期化する();


                // スキニング

                スキニング = スキニングを初期化して返す();


                // モーフ管理

                モーフ管理 = new モーフ管理(this);


                _初期化済み = true;
            }


            // モーション管理

            モーション管理 = モーション管理を初期化して返す();


            // その他

            その他の初期化(RenderContext.Instance.DeviceManager.D3DDevice);


            sw.Stop();                                      // 読み込み時間の計測終了
            Trace.WriteLine(sw.ElapsedMilliseconds + "ms"); // 読み込みにかかった時間をログ表示
        }
コード例 #4
0
        public void モーションを1フレーム進める(int fps, float elapsedTime, モーフ管理 morphManager)
        {
            // 行列の更新
            foreach (var boneMotion in _ボーンモーションのリスト)
            {
                boneMotion.ボーンを指定したフレームの姿勢に更新する(現在のフレーム);
            }

            foreach (var morphMotion in _モーフモーションのリスト)
            {
                morphManager.進捗率を設定する(morphMotion.指定したフレームにおけるモーフ値を取得する((ulong)現在のフレーム), morphMotion.モーフ名);
            }

            if (!_再生中である)
            {
                return;
            }

            現在のフレーム += (float)elapsedTime * fps;

            if (現在のフレーム >= このモーションにおける最終フレーム)
            {
                現在のフレーム = このモーションにおける最終フレーム;
            }

            FrameTicked?.Invoke(this, new EventArgs());

            if (現在のフレーム >= このモーションにおける最終フレーム)
            {
                モーションが終了した?.Invoke(this, _モーション再生終了後の挙動);

                if (_モーション再生終了後の挙動 == モーション再生終了後の挙動.Replay)
                {
                    現在のフレーム = 1.0e-3f;
                }
            }
        }
コード例 #5
0
        public override void  数を更新する(EffectVariable 数, 数更新時引数 引数)
        {
            var currentModel = RenderContext.Instance.描画ターゲットコンテキスト.ワールド空間.Drawableを取得する(_name);

            if (currentModel == null)
            {
                return;
            }

            IDrawable targetDrawable = (_isSelf) ? 引数.モデル : currentModel;

            if (_target == TargetObject.UnUsed)
            {
                switch (_variableType)
                {
                case  数型.Float4x4:
                    数.AsMatrix().SetMatrix(RenderContext.Instance.行列管理.ワールド行列管理.モデルのワールド変換行列を作成して返す(targetDrawable));
                    break;

                case  数型.Float3:
                    数.AsVector().Set(targetDrawable.モデル状態.位置);
                    break;

                case  数型.Float4:
                    数.AsVector().Set(new Vector4(targetDrawable.モデル状態.位置, 1f));
                    break;

                case  数型.Float:
                    数.AsScalar().Set(targetDrawable.モデル状態.率.Length());
                    break;

                case  数型.Bool:
                    数.AsScalar().Set(targetDrawable.表示中);
                    break;

                default:
                    break;
                }
            }
            else if (_target == TargetObject.BoneName)
            {
                IEnumerable <PMXボーン> targetBone = (from bone in ((PMXModel)targetDrawable).スキニング.ボーン配列 where bone.ボーン名 == _itemName select bone);

                foreach (var bone in targetBone)
                {
                    Matrix mat = bone.モデルポーズ行列 * RenderContext.Instance.行列管理.ワールド行列管理.モデルのワールド変換行列を作成して返す(targetDrawable);

                    switch (_variableType)
                    {
                    case  数型.Float4x4:
                        数.AsMatrix().SetMatrix(mat);
                        break;

                    case  数型.Float3:
                        数.AsVector().Set(Vector3.TransformCoordinate(bone.ローカル位置, mat));
                        break;

                    case  数型.Float4:
                        数.AsVector().Set(new Vector4(Vector3.TransformCoordinate(bone.ローカル位置, mat), 1f));
                        break;

                    default:
                        break;
                    }
                    break;
                }
            }
            else if (_target == TargetObject.FaceName)
            {
                モーフ管理 morphManager = ((PMXModel)targetDrawable).モーフ管理;

                数.AsScalar().Set(morphManager.モーフの進捗率を返す(_name));
            }
            else
            {
                switch (_target)
                {
                case TargetObject.X:
                    数.AsScalar().Set(targetDrawable.モデル状態.位置.X);
                    break;

                case TargetObject.Y:
                    数.AsScalar().Set(targetDrawable.モデル状態.位置.Y);
                    break;

                case TargetObject.Z:
                    数.AsScalar().Set(targetDrawable.モデル状態.位置.Z);
                    break;

                case TargetObject.XYZ:
                    数.AsVector().Set(targetDrawable.モデル状態.位置);
                    break;

                case TargetObject.Rx:
                case TargetObject.Ry:
                case TargetObject.Rz:
                case TargetObject.Rxyz:
                    float xRotation, yRotation, zRotation;     //X,Y,Z軸回転量に変換する。
                                                               //int type = 0; //分解パターン
                    if (!CGHelper.クォータニオンをXYZ回転に分解する(targetDrawable.モデル状態.回転, out xRotation, out yRotation, out zRotation))
                    {
                        if (!CGHelper.クォータニオンをYZX回転に分解する(targetDrawable.モデル状態.回転, out yRotation, out zRotation, out xRotation))
                        {
                            CGHelper.クォータニオンをZXY回転に分解する(targetDrawable.モデル状態.回転, out zRotation, out xRotation, out yRotation);
                            //		type = 2;
                        }
                        else
                        {
                            //		type = 1;
                        }
                    }
                    else
                    {
                        //	type = 0;
                    }

                    if (_target == TargetObject.Rx)
                    {
                        数.AsScalar().Set(xRotation);
                    }
                    else if (_target == TargetObject.Ry)
                    {
                        数.AsScalar().Set(yRotation);
                    }
                    else if (_target == TargetObject.Rz)
                    {
                        数.AsScalar().Set(zRotation);
                    }
                    else
                    {
                        数.AsVector().Set(new Vector3(xRotation, yRotation, zRotation));
                    }
                    break;

                case TargetObject.Si:
                    数.AsScalar().Set(targetDrawable.モデル状態.率.Length());
                    break;

                case TargetObject.Tr:
                    // TODO: Trへの対応
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
        }