Example #1
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mScreenRatio);
                s.Read(out mSize);
            }
Example #2
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mData.X);
            s.Read(out mData.Y);
        }
Example #3
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mMapId);

            s.Read(out mFlags);
            mFlags &= 0x3FF;

            s.Read(out mMapType);
            s.Read(out mImageId);
            mBounds = new RectangleValue(requestedApiVersion, handler, stream);
            s.Read(out mChannel);
            s.Read(out mOpKind);

            s.Read(out mOpArgMapId1);
            s.Read(out mOpArgMapId2);
            s.Read(out mOpArgMapId3);
            s.Read(out mOpArgMapId4);

            mOpArgValue1 = new Vector4ValueLE(requestedApiVersion, handler, stream);
            mOpArgValue2 = new Vector4ValueLE(requestedApiVersion, handler, stream);
            mOpArgValue3 = new Vector4ValueLE(requestedApiVersion, handler, stream);
            mOpArgValue4 = new Vector4ValueLE(requestedApiVersion, handler, stream);
        }
Example #4
0
        protected override void Parse(Stream s)
        {
            var sw = new BinaryStreamWrapper(s, ByteOrder.LittleEndian);

            sw.Read(out mData.R);
            sw.Read(out mData.G);
            sw.Read(out mData.B);
        }
Example #5
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mStrengthCurve = new DataList <FloatValue>(handler, stream);
                s.Read(out mRange);
                s.Read(out mKillRange);
            }
Example #6
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mEmitScale);
                s.Read(out mSizeScale);
                s.Read(out mAlphaScale);
            }
Example #7
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mType);
                s.Read(out mDestination);
                s.Read(out mSource);
                mParameters = new DataList <ByteValue>(handler, stream);
            }
Example #8
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mData.Left);
            s.Read(out mData.Top);
            s.Read(out mData.Right);
            s.Read(out mData.Bottom);
        }
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            s.Read(out mScale);
            mOrientation = new Matrix3x3Value(0, handler, stream);
            mPosition    = new Vector3ValueLE(0, handler, stream);
        }
Example #10
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mLengthRange = new Vector2ValueLE(requestedApiVersion, handler, stream);
                mCurve       = new DataList <FloatValue>(handler, stream);
                s.Read(out mCurveVary);
                s.Read(out mSpeedScale);
                s.Read(out mChannelId);
                s.Read(out mMode);
            }
Example #11
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mLifetime);
            s.Read(out mFadeTime);
            mStrengthCurve  = new DataList <FloatValue>(handler, stream);
            mFrequencyCurve = new DataList <FloatValue>(handler, stream);
            s.Read(out mAspectRatio);
            s.Read(out mBaseTableType);
            s.Read(out mFalloff);
        }
Example #12
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mTime     = new Vector2ValueLE(requestedApiVersion, handler, stream);
                mStrength = new Vector2ValueLE(requestedApiVersion, handler, stream);
                s.Read(out mTurnRange);
                s.Read(out mTurnOffset);
                s.Read(out mMix);
                mTurnOffsets = new DataList <FloatValue>(handler, stream);
                s.Read(out mWalkLoopType);
            }
Example #13
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                if (isTheSims4)
                {
                    s.Read(out mData);
                }
                else
                {
                    uint data;
                    s.Read(out data);
                    mData = data;
                }
            }
Example #14
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mTimeRange = new Vector2ValueLE(requestedApiVersion, handler, stream);
                s.Read(out mEffectName, StringType.ZeroDelimited);
            }
Example #15
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mParticleLifetime = new Vector2ValueLE(requestedApiVersion, handler, stream);
                s.Read(out mPrerollTime);
                mEmitDelay     = new Vector2ValueLE(requestedApiVersion, handler, stream);
                mEmitRetrigger = new Vector2ValueLE(requestedApiVersion, handler, stream);
                mEmitDirection = new BoundingBoxValue(requestedApiVersion, handler, stream);
                mEmitSpeed     = new Vector2ValueLE(requestedApiVersion, handler, stream);
                mEmitVolume    = new BoundingBoxValue(requestedApiVersion, handler, stream);
                if (bHasTorus)
                {
                    s.Read(out mEmitTorusWidth);
                }
            }
Example #16
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mTimeRate);
                mRateDir   = new Vector3ValueLE(requestedApiVersion, handler, stream);
                mWiggleDir = new Vector3ValueLE(requestedApiVersion, handler, stream);
            }
Example #17
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            mElements = new DataList <Element>(handler, stream);
            s.Read(out mFlags);
            //mFlags &= 0xF;
        }
Example #18
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                mPosition = new Vector3ValueLE(requestedApiVersion, handler, stream);
                mVelocity = new Vector3ValueLE(requestedApiVersion, handler, stream);
                s.Read(out mTime);
            }
Example #19
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x3FF;

            s.Read(out mViewFlags);
            s.Read(out mLifetime);
            mHeadingCurve  = new DataList <FloatValue>(handler, stream);
            mPitchCurve    = new DataList <FloatValue>(handler, stream);
            mRollCurve     = new DataList <FloatValue>(handler, stream);
            mDistanceCurve = new DataList <FloatValue>(handler, stream);
            mFOVCurve      = new DataList <FloatValue>(handler, stream);
            mNearClipCurve = new DataList <FloatValue>(handler, stream);
            mFarClipCurve  = new DataList <FloatValue>(handler, stream);
            s.Read(out mCameraId);
            s.Read(out mCubemapResource);
        }
Example #20
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mFlags);
                //mFlags &= 0x3FFF;

                s.Read(out mId);
                s.Read(out mBounce);
                s.Read(out mSlide);
                s.Read(out mCollisionRadius);
                s.Read(out mDeathProbability);
                s.Read(out mPinOffset);
                s.Read(out mString01, StringType.ZeroDelimited);
                s.Read(out mString02, StringType.ZeroDelimited);
                mData = new DataList <Vector3ValueLE>(handler, stream);
            }
Example #21
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x3FF;

            s.Read(out mMessageId);
            s.Read(out mMessageData1);
            s.Read(out mMessageData2);
            s.Read(out mMessageData3);
            s.Read(out mMessageData4);
            s.Read(out mMessageString, StringType.ZeroDelimited);
            s.Read(out mLife);
        }
Example #22
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x1FFF;

            mParticleParameters = new ParticleParams(requestedApiVersion, handler, false, stream);
            mRateCurve          = new DataList <FloatValue>(handler, stream);
            s.Read(out mRateCurveTime);
            s.Read(out mRateCurveCycles);
            s.Read(out mRateSpeedScale);
            mSizeCurve  = new DataList <FloatValue>(handler, stream);
            mColorCurve = new DataList <ColorValue>(handler, stream);
            mAlphaCurve = new DataList <FloatValue>(handler, stream);
            mDrawInfo   = new ResourceReference(requestedApiVersion, handler, mSection, stream);
            s.Read(out mAlignMode);
            mDirectionalForcesSum = new Vector3ValueLE(requestedApiVersion, handler, stream);
            s.Read(out mWindStrength);
            s.Read(out mGravityStrength);
            s.Read(out mRadialForce);
            mRadialForceLocation = new Vector3ValueLE(requestedApiVersion, handler, stream);
            s.Read(out mDrag);
        }
Example #23
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            s.Read(out mComponentAppFlagsMask);
            s.Read(out mNotifyMessageId);
            mScreenSizeRange = new Vector2ValueLE(requestedApiVersion, handler, stream);
            s.Read(out mCursorActiveDistance);
            s.Read(out mCursorButton);
            mLODDistances       = new DataList <FloatValue>(handler, stream);
            mExtendedLODWeights = new Vector3ValueLE(requestedApiVersion, handler, stream);
            s.Read(out mSeed);
            mDescriptions = new SectionDataList <Description>(handler, mSection, stream);
        }
Example #24
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x3;

            s.Read(out mResourceId);
            s.Read(out mSize);
            mColor = new ColorValue(requestedApiVersion, handler, stream);
            s.Read(out mAlpha);
            mAnimationCurves = new DataList <AnimationCurve>(handler, stream);
            s.Read(out mMaterialId);
            s.Read(out mOverrideSet);
        }
Example #25
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0xF;

            s.Read(out mSoundId);
            s.Read(out mLocationUpdateDelta);
            s.Read(out mPlayTime);
            s.Read(out mVolume);
            if (isTheSims4 && mSection.Version >= 0x0002 && stream.Position < stream.Length)
            {
                s.Read(out mByte01);
            }
        }
Example #26
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mMode);
            s.Read(out mFlags);
            //mFlags &= 0x3;

            mColorCurve    = new DataList <ColorValue>(handler, stream);
            mStrengthCurve = new DataList <FloatValue>(handler, stream);
            mDistanceCurve = new DataList <FloatValue>(handler, stream);
            s.Read(out mLifetime);
            s.Read(out mDelay);
            s.Read(out mFalloff);
            s.Read(out mDistanceBase);
            s.Read(out mTextureId);
            mFilters              = new DataList <Filter>(handler, stream);
            mTemporaryBuffers     = new DataList <FilterTempBuffer>(handler, stream);
            mFloatParameters      = new DataList <FloatValue>(handler, stream);
            mVector3Parameters    = new DataList <Vector3ValueLE>(handler, stream);
            mVector2Parameters    = new DataList <Vector2ValueLE>(handler, stream);
            mResourceIdParameters = new DataList <ResourceId>(handler, stream);
        }
Example #27
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            // no flag mask

            ParticleParameters = new ParticleParams(requestedApiVersion, handler, true, stream);
            mRateCurve         = new DataList <FloatValue>(handler, stream);
            s.Read(out mRateCurveTime);
            s.Read(out mRateCurveCycles);
            s.Read(out mRateSpeedScale);
            mSizeCurve = new DataList <FloatValue>(handler, stream);
            s.Read(out mSizeVary);
            mAspectCurve = new DataList <FloatValue>(handler, stream);
            s.Read(out mAspectVary);
            s.Read(out mRotationVary);
            s.Read(out mRotationOffset);
            mRotationCurve = new DataList <FloatValue>(handler, stream);
            mAlphaCurve    = new DataList <FloatValue>(handler, stream);
            s.Read(out mAlphaVary);
            mColorCurve = new DataList <ColorValue>(handler, stream);
            mColorVary  = new ColorValue(requestedApiVersion, handler, stream);
            mDrawInfo   = new ResourceReference(0, handler, mSection, stream);

            s.Read(out mPhysicsType);
            s.Read(out mOverrideSet);
            s.Read(out mTileCountU);
            s.Read(out mTileCountV);
            s.Read(out mAlignMode);
            s.Read(out mFrameSpeed);
            s.Read(out mFrameStart);
            s.Read(out mFrameCount);
            s.Read(out mFrameRandom);

            mDirectionalForcesSum = new Vector3ValueLE(requestedApiVersion, handler, stream);

            s.Read(out mWindStrength);
            s.Read(out mGravityStrength);
            s.Read(out mRadialForce);

            mRadialForceLocation = new Vector3ValueLE(requestedApiVersion, handler, stream);

            s.Read(out mDrag);
            s.Read(out mVelocityStretch);
            s.Read(out mScrewRate);

            mWiggles = new DataList <Wiggle>(handler, stream);
            s.Read(out mScreenBloomAlphaRate);
            s.Read(out mScreenBloomAlphaBase);
            s.Read(out mScreenBloomSizeRate);
            s.Read(out mScreenBloomSizeBase);
            mLoopBoxColorCurve = new DataList <ColorValue>(handler, stream);
            mLoopBoxAlphaCurve = new DataList <FloatValue>(handler, stream);
            mSurfaces          = new DataList <Surface>(handler, stream);
            s.Read(out mMapBounce);
            s.Read(out mMapRepulseHeight);
            s.Read(out mMapRepulseStrength);
            s.Read(out mMapRepulseScoutDistance);
            s.Read(out mMapRepulseVertical);

            s.Read(out mMapRepulseKillHeight);                                         //-1000000000.0f
            s.Read(out mProbabilityDeath);                                             //0f
            mAltitudeRange = new Vector2ValueLE(requestedApiVersion, handler, stream); // (-10000.0f, 10000.0f)

            s.Read(out mForceMapId);
            s.Read(out mEmitRateMapId);
            s.Read(out mEmitColorMapId);
            mRandomWalk = new RandomWalk(requestedApiVersion, handler, stream);

            mAttractorOrigin = new Vector3ValueLE(requestedApiVersion, handler, stream);

            mAttractor = new Attractor(requestedApiVersion, handler, stream);

            mPathPoints = new DataList <PathPoint>(handler, stream);

            //Version 2+
            if (mSection.Version >= 0x0002 && stream.Position < stream.Length)
            {
                mVector01      = new Vector3ValueLE(requestedApiVersion, handler, stream);
                mVector3List01 = new DataList <Vector3ValueLE>(handler, stream);
            }

            //Version 3+
            if (mSection.Version >= 0x0003 && stream.Position < stream.Length)
            {
                s.Read(out mByte01);
            }

            //Version 4+
            if (mSection.Version >= 0x0004 && stream.Position < stream.Length)
            {
                s.Read(out mFloat01);
            }

            //Version 5+
            if (mSection.Version >= 0x0005 && stream.Position < stream.Length)
            {
                if (isTheSims4)
                {
                    mVector02 = new Vector3ValueLE(requestedApiVersion, handler, stream);
                    s.Read(out mUnknown170);
                }
                else
                {
                    float value;
                    s.Read(out value);
                    mVector02 = new Vector3ValueLE(requestedApiVersion, handler, value, value, value);
                }
            }

            if (isTheSims4)
            {
                //Version 6+
                if (mSection.Version >= 0x0006 && stream.Position < stream.Length)
                {
                    mUnknown140 = new Vector2ValueLE(requestedApiVersion, handler, stream);
                }
                else
                {
                    float value;
                    s.Read(out value);
                    mUnknown140 = new Vector2ValueLE(requestedApiVersion, handler, value, value);
                }

                //Version 7+
                if (mSection.Version >= 0x0007 && stream.Position < stream.Length)
                {
                    mUnknown150 = new Vector2ValueLE(requestedApiVersion, handler, stream);
                }

                s.Read(out mUnknown160);
                s.Read(out mUnknown164);

                s.Read(out mUnknown1C1);
                if (mUnknown1C1 != 0 && stream.Position < stream.Length)
                {
                    mUnknown180 = new Vector3ValueLE(requestedApiVersion, handler, stream);
                    s.Read(out mUnknown1C0);

                    if (mSection.Version >= 0x0006 && stream.Position < stream.Length)
                    {
                        mUnknown190 = new Vector2ValueLE(requestedApiVersion, handler, stream);
                    }
                    else
                    {
                        float value;
                        s.Read(out value);
                        mUnknown190 = new Vector2ValueLE(requestedApiVersion, handler, value, value);
                    }

                    if (mSection.Version >= 0x0007 && stream.Position < stream.Length)
                    {
                        mUnknown1A0 = new Vector2ValueLE(requestedApiVersion, handler, stream);
                    }

                    s.Read(out mUnknown1B0);
                    s.Read(out mUnknown1B4);
                }

                if (mSection.Version >= 0x0006 && stream.Position < stream.Length)
                {
                    s.Read(out mUnknown208);
                    if (mUnknown208 != 0)
                    {
                        s.Read(out mUnknown20C);
                        s.Read(out mUnknown209);
                        s.Read(out mUnknown20A);
                        s.Read(out mUnknown20B);
                    }
                }
            }
        }
Example #28
0
            protected override void Parse(Stream stream)
            {
                var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

                s.Read(out mComponentType);
                s.Read(out mFlags);
                mLocalXForm = new TransformElement(requestedApiVersion, handler, stream);
                s.Read(out mLODBegin);
                s.Read(out mLODEnd);
                mLODScales = new DataList <LODScale>(handler, stream);
                s.Read(out mEmitScaleBegin);  //1.0
                s.Read(out mEmitScaleEnd);    //1.0
                s.Read(out mSizeScaleBegin);  //1.0
                s.Read(out mSizeScaleEnd);    //1.0
                s.Read(out mAlphaScaleBegin); //1.0
                s.Read(out mAlphaScaleEnd);   //1.0
                s.Read(out mAppFlags);
                s.Read(out mAppFlagsMask);
                s.Read(out mSelectionGroup);
                s.Read(out mSelectionChance);
                s.Read(out mTimeScale);
                s.Read(out mComponentIndex);
                if (mSection.Version >= 2 && stream.Position < stream.Length)
                {
                    s.Read(out mByte03); //version 2+
                    s.Read(out mByte04); //version 2+
                }
                if (mSection.Version >= 3 && stream.Position < stream.Length)
                {
                    mFloatList01 = new DataList <FloatValue>(handler, stream);//version 3+
                }
                else
                {
                    mFloatList01 = new DataList <FloatValue>(handler);
                }
            }
Example #29
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x7F;

            s.Read(out mDdsResource);
            s.Read(out mByte01);
            s.Read(out mInt01);
            s.Read(out mByte02);
            if (isTheSims4)
            {
                s.Read(out mInt02);
            }
            s.Read(out mLifetime);
            mRotationCurve = new DataList <FloatValue>(handler, stream);
            mSizeCurve     = new DataList <FloatValue>(handler, stream);
            mAlphaCurve    = new DataList <FloatValue>(handler, stream);
            mColorCurve    = new DataList <ColorValue>(handler, stream);
            mAspectCurve   = new DataList <FloatValue>(handler, stream);
            s.Read(out mAlphaVary);
            s.Read(out mSizeVary);
            s.Read(out mRotationVary);
            s.Read(out mTextureRepeat);
            mTextureOffset = new Vector2ValueLE(requestedApiVersion, handler, stream);
            s.Read(out mEmitColorMapId);
            if (mSection.Version >= 2 && stream.Position < stream.Length)
            {
                s.Read(out mByte03);                                                           //version 2+
            }
        }
Example #30
0
        protected override void Parse(Stream stream)
        {
            var s = new BinaryStreamWrapper(stream, ByteOrder.BigEndian);

            s.Read(out mFlags);
            //mFlags &= 0x3FFF;

            mRibbonLifetime = new Vector2ValueLE(requestedApiVersion, handler, stream);
            mOffsetCurve    = new DataList <FloatValue>(handler, stream);
            mWidthCurve     = new DataList <FloatValue>(handler, stream);
            s.Read(out mTaper);
            s.Read(out mFade);
            s.Read(out mAlphaDecay);
            mColorCurve          = new DataList <ColorValue>(handler, stream);
            mAlphaCurve          = new DataList <FloatValue>(handler, stream);
            mLengthColorCurve    = new DataList <ColorValue>(handler, stream);
            mLengthAlphaCurve    = new DataList <FloatValue>(handler, stream);
            mEdgeColorCurve      = new DataList <ColorValue>(handler, stream);
            mEdgeAlphaCurve      = new DataList <FloatValue>(handler, stream);
            mStartEdgeAlphaCurve = new DataList <FloatValue>(handler, stream);
            mEndEdgeAlphaCurve   = new DataList <FloatValue>(handler, stream);
            s.Read(out mSegmentCount);
            s.Read(out mSegmentLength);
            mDrawInfo = new ResourceReference(requestedApiVersion, handler, mSection, stream);
            s.Read(out mTileUV);
            s.Read(out mSlipCurveSpeed);
            s.Read(out mSlipUVSpeed);

            if (mSection.Version >= 0x0002)
            {
                s.Read(out mUVRepeat);
            }
            else
            {
                mUVRepeat = 1.0f;
            }

            mDirectionalForcesSum = new Vector3ValueLE(requestedApiVersion, handler, stream);

            s.Read(out mWindStrength);
            s.Read(out mGravityStrength);
            s.Read(out mEmitColorMapId);
            s.Read(out mForceMapId);
            s.Read(out mMapRepulseStrength);
        }