Пример #1
0
        public override void Read(AssetStream stream)
        {
            base.Read(stream);

            Type = stream.ReadInt32();
            if (IsReadRadiusSingle(stream.Version))
            {
                RadiusSingle = stream.ReadSingle();
            }
            if (IsReadAngle(stream.Version))
            {
                Angle  = stream.ReadSingle();
                Length = stream.ReadSingle();
            }
            if (IsReadBoxAxes(stream.Version))
            {
                BoxX = stream.ReadSingle();
                BoxY = stream.ReadSingle();
                BoxZ = stream.ReadSingle();
            }
            if (IsReadArcSingle(stream.Version))
            {
                ArcSingle = stream.ReadSingle();
            }
            if (IsReadRadius(stream.Version))
            {
                if (IsReadRadiusFirst(stream.Version))
                {
                    Radius.Read(stream);
                    Arc.Read(stream);
                }
            }
            if (IsReadBoxThickness(stream.Version))
            {
                BoxThickness.Read(stream);
                RadiusThickness = stream.ReadSingle();
                DonutRadius     = stream.ReadSingle();
                Position.Read(stream);
                Rotation.Read(stream);
                Scale.Read(stream);
            }
            if (IsReadPlacementMode(stream.Version))
            {
                PlacementMode = stream.ReadInt32();
            }
            if (IsReadMeshMaterialIndex(stream.Version))
            {
                if (IsReadMeshMaterialIndexFirst(stream.Version))
                {
                    MeshMaterialIndex = stream.ReadInt32();
                    MeshNormalOffset  = stream.ReadSingle();
                }
            }
            if (IsReadMesh(stream.Version))
            {
                Mesh.Read(stream);
            }
            if (IsReadMeshRenderer(stream.Version))
            {
                MeshRenderer.Read(stream);
                SkinnedMeshRenderer.Read(stream);
            }
            if (IsReadMeshMaterialIndex(stream.Version))
            {
                if (!IsReadMeshMaterialIndexFirst(stream.Version))
                {
                    MeshMaterialIndex = stream.ReadInt32();
                    MeshNormalOffset  = stream.ReadSingle();
                }
            }
            if (IsReadMeshScale(stream.Version))
            {
                MeshScale = stream.ReadSingle();
            }
            if (IsReadUseMeshMaterialIndex(stream.Version))
            {
                UseMeshMaterialIndex = stream.ReadBoolean();
                UseMeshColors        = stream.ReadBoolean();
            }
            if (IsReadAlignToDirection(stream.Version))
            {
                AlignToDirection = stream.ReadBoolean();
            }
            if (IsReadRandomDirection(stream.Version))
            {
                RandomDirection = stream.ReadBoolean();
            }
            stream.AlignStream(AlignType.Align4);

            if (IsReadRandomDirectionAmount(stream.Version))
            {
                RandomDirectionAmount    = stream.ReadSingle();
                SphericalDirectionAmount = stream.ReadSingle();
            }
            if (IsReadRandomPositionAmount(stream.Version))
            {
                RandomPositionAmount = stream.ReadSingle();
            }
            if (IsReadRadius(stream.Version))
            {
                if (!IsReadRadiusFirst(stream.Version))
                {
                    Radius.Read(stream);
                    Arc.Read(stream);
                }
            }
        }
Пример #2
0
        public override void Read(AssetStream stream)
        {
            if (IsReadRenderer(stream.Version))
            {
                base.Read(stream);
            }
            else
            {
                ReadBase(stream);
            }

            if (IsReadQuality(stream.Version))
            {
                if (IsReadQualityFirst(stream.Version))
                {
                    Quality = stream.ReadInt32();
                }
            }
            if (IsReadUpdateWhenOffscreen(stream.Version))
            {
                UpdateWhenOffscreen = stream.ReadBoolean();
            }
            if (IsReadQuality(stream.Version))
            {
                if (!IsReadQualityFirst(stream.Version))
                {
                    Quality = stream.ReadInt32();
                }
            }

            if (IsReadSkinNormals(stream.Version))
            {
                SkinNormals = stream.ReadBoolean();
            }
            if (IsReadSkinMotionVector(stream.Version))
            {
                SkinnedMotionVectors = stream.ReadBoolean();
            }
            if (IsAlignBools(stream.Version))
            {
                stream.AlignStream(AlignType.Align4);
            }

            if (IsReadOffscreen(stream.Version))
            {
                DisableAnimationWhenOffscreen.Read(stream);
            }

            if (IsReadMeshFirst(stream.Version))
            {
                Mesh.Read(stream);
            }

            if (IsReadAnimation(stream.Version))
            {
                Animation.Read(stream);
            }

            m_bones = stream.ReadArray <PPtr <Transform> >();
            if (IsAlignBones(stream.Version))
            {
                stream.AlignStream(AlignType.Align4);
            }

            if (!IsReadMeshFirst(stream.Version))
            {
                Mesh.Read(stream);
            }

            if (IsReadBindPose(stream.Version))
            {
                m_bindPose = stream.ReadArray <Matrix4x4f>();
            }
            if (IsReadCurrentPose(stream.Version))
            {
                CurrentPose.Read(stream);
            }

            if (IsReadWeights(stream.Version))
            {
                m_blendShapeWeights = stream.ReadSingleArray();
            }
            if (IsReadRootBone(stream.Version))
            {
                RootBone.Read(stream);
            }
            if (IsReadAABB(stream.Version))
            {
                AABB.Read(stream);
                DirtyAABB = stream.ReadBoolean();
                stream.AlignStream(AlignType.Align4);
            }
        }