コード例 #1
0
        public static void FromJson(MaterialAnim anim, string json)
        {
            JsonConvert.DefaultSettings = () =>
            {
                var settings = new JsonSerializerSettings();
                return(settings);
            };

            var animJson = JsonConvert.DeserializeObject <MaterialAnimStuct>(json);

            anim.Name = animJson.Name;
            anim.MaterialAnimDataList = new List <MaterialAnimData>();
            anim.UserData             = UserDataConvert.Convert(animJson.UserData);
            anim.FrameCount           = animJson.FrameCount;
            if (animJson.Loop)
            {
                anim.Flags |= MaterialAnim.MaterialAnimFlags.Looping;
            }
            if (animJson.Baked)
            {
                anim.Flags |= MaterialAnim.MaterialAnimFlags.BakedCurve;
            }

            foreach (var matAnimJson in animJson.MaterialAnims)
            {
                MaterialAnimData matAnim = new MaterialAnimData();
                anim.MaterialAnimDataList.Add(matAnim);

                matAnim.Name             = matAnimJson.Name;
                matAnim.PatternAnimInfos = matAnimJson.PatternAnimInfos;
                matAnim.ParamAnimInfos   = matAnimJson.ParameterInfos;
                matAnim.Constants        = matAnimJson.Constants;
                matAnim.BaseDataList     = matAnimJson.BaseDataList.ToArray();

                foreach (var curveJson in matAnimJson.Curves)
                {
                    var target = uint.Parse(curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    matAnim.Curves.Add(curve);
                }
            }
        }
コード例 #2
0
        public static void FromJson(VisibilityAnim anim, string json)
        {
            JsonConvert.DefaultSettings = () =>
            {
                var settings = new JsonSerializerSettings();
                return(settings);
            };

            var animJson = JsonConvert.DeserializeObject <BoneVisibilityAnimStruct>(json);

            anim.Name        = animJson.Name;
            anim.Baked       = animJson.Baked;
            anim.Loop        = animJson.Loop;
            anim.FrameCount  = animJson.FrameCount;
            anim.Baked       = animJson.Baked;
            anim.BindIndices = new ushort[animJson.Groups.Count];
            anim.UserData    = UserDataConvert.Convert(animJson.UserData);

            foreach (var groupAnimJson in animJson.Groups)
            {
                var curve = groupAnimJson.Curves;
            }
        }
コード例 #3
0
        public static List <MeshMetaInfo> FromJson(Material mat, string json)
        {
            JsonConvert.DefaultSettings = () =>
            {
                var settings = new JsonSerializerSettings();
                return(settings);
            };

            var matJson = JsonConvert.DeserializeObject <MaterialStruct>(json);

            mat.Name            = matJson.Name;
            mat.Visible         = matJson.Visible;
            mat.ShaderAssign    = ConvertShaderAssign(matJson.ShaderAssign);
            mat.TextureRefs     = new List <TextureRef>();
            mat.Samplers        = new ResDict <Sampler>();
            mat.ShaderParams    = new ResDict <ShaderParam>();
            mat.UserData        = new ResDict <UserData>();
            mat.RenderInfos     = new ResDict <RenderInfo>();
            mat.ShaderParamData = new byte[0];
            mat.VolatileFlags   = new byte[0];

            if (matJson.RenderState != null)
            {
                mat.RenderState = matJson.RenderState;
            }

            foreach (var tex in matJson.Textures)
            {
                mat.TextureRefs.Add(new TextureRef()
                {
                    Name = tex
                });
            }

            foreach (var sampler in matJson.Samplers)
            {
                mat.Samplers.Add(sampler.Name, sampler);
            }

            mat.TextureSlotArray = new long[matJson.Textures.Count];
            mat.SamplerSlotArray = new long[matJson.Textures.Count];

            mat.VolatileFlags = matJson.VolatileFlags;
            foreach (var param in matJson.Parameters)
            {
                string type = param.Key.Split('|')[0];
                string name = param.Key.Split('|')[1];

                ShaderParam shaderParam = new ShaderParam();
                shaderParam.Name = name;
                var dataType = (ShaderParamType)Enum.Parse(typeof(ShaderParamType), type);

                object value = null;
                switch (dataType)
                {
                case ShaderParamType.Float:
                    value = Convert.ToSingle(param.Value);
                    break;

                case ShaderParamType.UInt:
                    value = Convert.ToUInt32(param.Value);
                    break;

                case ShaderParamType.Int:
                    value = Convert.ToInt32(param.Value);
                    break;

                case ShaderParamType.Bool:
                    value = Convert.ToBoolean(param.Value);
                    break;

                case ShaderParamType.Srt2D:
                    value = ((JObject)param.Value).ToObject <Srt2D>();
                    break;

                case ShaderParamType.Srt3D:
                    value = ((JObject)param.Value).ToObject <Srt3D>();
                    break;

                case ShaderParamType.TexSrt:
                    value = ((JObject)param.Value).ToObject <TexSrt>();
                    break;

                case ShaderParamType.TexSrtEx:
                    value = ((JObject)param.Value).ToObject <TexSrt>();
                    break;

                case ShaderParamType.Float2:
                case ShaderParamType.Float2x2:
                case ShaderParamType.Float2x3:
                case ShaderParamType.Float2x4:
                case ShaderParamType.Float3:
                case ShaderParamType.Float3x2:
                case ShaderParamType.Float3x3:
                case ShaderParamType.Float3x4:
                case ShaderParamType.Float4:
                case ShaderParamType.Float4x2:
                case ShaderParamType.Float4x3:
                case ShaderParamType.Float4x4:
                    value = ((JArray)param.Value).ToObject <float[]>();
                    break;

                case ShaderParamType.Bool2:
                case ShaderParamType.Bool3:
                case ShaderParamType.Bool4:
                    value = ((JArray)param.Value).ToObject <bool>();
                    break;

                case ShaderParamType.Int2:
                case ShaderParamType.Int3:
                case ShaderParamType.Int4:
                    value = ((JArray)param.Value).ToObject <int[]>();
                    break;

                case ShaderParamType.UInt2:
                case ShaderParamType.UInt3:
                case ShaderParamType.UInt4:
                    value = ((JArray)param.Value).ToObject <uint[]>();
                    break;

                default:
                    throw new Exception($"Unsupported parameter type! {type}");
                }

                mat.SetShaderParameter(name, dataType, value);
            }

            foreach (var param in matJson.RenderInfo)
            {
                string         type     = param.Key.Split('|')[0];
                string         name     = param.Key.Split('|')[1];
                RenderInfoType dataType = (RenderInfoType)Enum.Parse(typeof(RenderInfoType), type);

                if (dataType == RenderInfoType.Single)
                {
                    mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <float[]>());
                }
                if (dataType == RenderInfoType.Int32)
                {
                    mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <int[]>());
                }
                if (dataType == RenderInfoType.String)
                {
                    mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <string[]>());
                }
            }
            mat.UserData = UserDataConvert.Convert(matJson.UserData);
            return(matJson.MeshInfo);
        }
コード例 #4
0
        public static void FromJson(SceneAnim anim, string json)
        {
            JsonConvert.DefaultSettings = () =>
            {
                var settings = new JsonSerializerSettings();
                return(settings);
            };

            var animJson = JsonConvert.DeserializeObject <SceneAnimStuct>(json);

            anim.Name        = animJson.Name;
            anim.CameraAnims = new ResDict <CameraAnim>();
            anim.LightAnims  = new ResDict <LightAnim>();
            anim.FogAnims    = new ResDict <FogAnim>();
            anim.UserData    = UserDataConvert.Convert(animJson.UserData);

            foreach (var camAnimJson in animJson.CameraAnims)
            {
                CameraAnim camAnim = new CameraAnim();
                camAnim.Flags = 0;

                anim.CameraAnims.Add(camAnimJson.Name, camAnim);

                if (camAnimJson.Loop)
                {
                    camAnim.Flags |= CameraAnimFlags.Looping;
                }
                if (camAnimJson.Baked)
                {
                    camAnim.Flags |= CameraAnimFlags.BakedCurve;
                }
                if (camAnimJson.Perspective)
                {
                    camAnim.Flags |= CameraAnimFlags.Perspective;
                }
                if (camAnimJson.EulerRotation)
                {
                    camAnim.Flags |= CameraAnimFlags.EulerZXY;
                }

                camAnim.Name       = camAnimJson.Name;
                camAnim.FrameCount = camAnimJson.FrameCount;
                camAnim.BaseData   = camAnimJson.BaseData;
                foreach (var curveJson in camAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    camAnim.Curves.Add(curve);
                }
            }
            foreach (var lightAnimJson in animJson.LightAnims)
            {
                LightAnim lightAnim = new LightAnim();
                lightAnim.Flags = 0;

                anim.LightAnims.Add(lightAnimJson.Name, lightAnim);

                if (lightAnimJson.Loop)
                {
                    lightAnim.Flags |= LightAnimFlags.Looping;
                }
                if (lightAnimJson.Baked)
                {
                    lightAnim.Flags |= LightAnimFlags.BakedCurve;
                }
                if (lightAnimJson.BaseAngleAttn)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseAngleAttn;
                }
                if (lightAnimJson.BaseColor0)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseColor0;
                }
                if (lightAnimJson.BaseColor1)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseColor1;
                }
                if (lightAnimJson.BaseDir)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseDir;
                }
                if (lightAnimJson.BaseDistAttn)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseDistAttn;
                }
                if (lightAnimJson.BasePos)
                {
                    lightAnim.Flags |= LightAnimFlags.BasePos;
                }

                lightAnim.Name       = lightAnimJson.Name;
                lightAnim.FrameCount = lightAnimJson.FrameCount;
                lightAnim.BaseData   = lightAnimJson.BaseData;

                if (lightAnim.BaseData.Enable == 1)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseEnable;
                }

                foreach (var curveJson in lightAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    lightAnim.Curves.Add(curve);
                }
            }
            foreach (var fogAnimJson in animJson.FogAnims)
            {
                FogAnim fogAnim = new FogAnim();
                fogAnim.Flags = 0;

                anim.CameraAnims.Add(fogAnimJson.Name, fogAnim);

                if (fogAnimJson.Loop)
                {
                    fogAnim.Flags |= FogAnimFlags.Looping;
                }
                if (fogAnimJson.Baked)
                {
                    fogAnim.Flags |= FogAnimFlags.BakedCurve;
                }

                fogAnim.Name                  = fogAnimJson.Name;
                fogAnim.FrameCount            = fogAnimJson.FrameCount;
                fogAnim.DistanceAttnFuncIndex = fogAnimJson.DistanceAttnFuncIndex;
                fogAnim.DistanceAttnFuncName  = fogAnimJson.DistanceAttnFuncName;
                fogAnim.BaseData              = fogAnimJson.BaseData;

                foreach (var curveJson in fogAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    fogAnim.Curves.Add(curve);
                }
            }
        }