Esempio n. 1
0
        public override bool OnInitialize()
        {
            _ref0 = Header->_ref0;
            _ref1 = Header->_ref1;
            _ref2 = Header->_ref2;
            _ref3 = Header->_ref3;
            _ref4 = Header->_ref4;
            _ref5 = Header->_ref5;
            _ref6 = Header->_ref6;
            _ref7 = Header->_ref7;

            //Attach to materials
            byte *pHeader = (byte *)Header;

            if ((Model != null) && (Model._matList != null))
            {
                foreach (MDL0MaterialNode mat in Model._matList)
                {
                    MDL0Material *mHeader = mat.Header;
                    if (((byte *)mHeader + mHeader->_shaderOffset) == pHeader)
                    {
                        mat._shader = this;
                        _materials.Add(mat);
                    }
                }
            }

            _swapBlock = *Header->SwapBlock;

            return(Header->_stages > 0);
        }
Esempio n. 2
0
        protected override bool OnInitialize()
        {
            MDL0Shader *header = Header;

            _datalen    = header->_dataLength;
            _mdl0offset = header->_mdl0Offset;

            stages = header->_stages;

            res0 = header->_res0;
            res1 = header->_res1;
            res2 = header->_res2;

            ref0 = header->_ref0;
            ref1 = header->_ref1;
            ref2 = header->_ref2;
            ref3 = header->_ref3;
            ref4 = header->_ref4;
            ref5 = header->_ref5;
            ref6 = header->_ref6;
            ref7 = header->_ref7;

            pad0 = header->_pad0;
            pad1 = header->_pad1;

            if (_name == null)
            {
                _name = String.Format("Shader{0}", Index);
            }

            //Attach to materials
            byte *pHeader = (byte *)Header;

            if ((Model != null) && (Model._matList != null))
            {
                foreach (MDL0MaterialNode mat in Model._matList)
                {
                    MDL0Material *mHeader = mat.Header;
                    if (((byte *)mHeader + mHeader->_shaderOffset) == pHeader)
                    {
                        mat._shader = this;
                        _materials.Add(mat);
                    }
                }
            }

            _swapBlock = *header->SwapBlock;
            getIRefValues();

            Populate();
            return(true);
        }
        public override bool OnInitialize()
        {
            MDL0Shader *header = Header;

            _datalen    = header->_dataLength;
            _mdl0offset = header->_mdl0Offset;

            _stages = header->_stages;

            _res0 = header->_res0;
            _res1 = header->_res1;
            _res2 = header->_res2;

            _ref0 = header->_ref0;
            _ref1 = header->_ref1;
            _ref2 = header->_ref2;
            _ref3 = header->_ref3;
            _ref4 = header->_ref4;
            _ref5 = header->_ref5;
            _ref6 = header->_ref6;
            _ref7 = header->_ref7;

            _pad0 = header->_pad0;
            _pad1 = header->_pad1;

            //Attach to materials
            byte *pHeader = (byte *)Header;

            if ((Model != null) && (Model._matList != null))
            {
                foreach (MDL0MaterialNode mat in Model._matList)
                {
                    MDL0Material *mHeader = mat.Header;
                    if (((byte *)mHeader + mHeader->_shaderOffset) == pHeader)
                    {
                        mat._shader = this;
                        _materials.Add(mat);
                    }
                }
            }

            _swapBlock = *header->SwapBlock;

            Populate();
            return(true);
        }
        protected override bool OnInitialize()
        {
            MDL0Material *header = Header;

            if ((_name == null) && (header->_stringOffset != 0))
            {
                _name = header->ResourceString;
            }

            _numTextures = header->_flag1;
            _numLayers   = header->_numLayers;
            _unk1        = header->_unk1;
            _unk3        = header->_unk3;
            _unk4        = header->_unk4;
            _unk6        = header->_unk6;
            _flag3       = header->_flag3;
            _flag4       = header->_flag4;
            _flag5       = header->_flag5;
            _flag6       = header->_flag6;
            _flag7       = header->_flag7;
            _flag8       = header->_flag8;
            _type        = header->_type;

            MatModeBlock *mode = header->DisplayLists;

            _alphaFunc     = mode->AlphaFunction;
            _zMode         = mode->ZMode;
            _blendMode     = mode->BlendMode;
            _constantAlpha = mode->ConstantAlpha;

            MDL0Data7Part4 *part4 = header->Part4;

            if (part4 != null)
            {
                ResourceGroup *group = part4->Group;
                for (int i = 0; i < group->_numEntries; i++)
                {
                    _part4Entries.Add(group->First[i].GetName());
                }
            }

            _children = new List <ResourceNode>();
            OnPopulate();
            return(true);
        }
        //protected override int OnCalculateSize(bool force)
        //{

        //}

        protected internal override void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable)
        {
            MDL0Material *header = (MDL0Material *)dataAddress;

            header->_mdl0Offset   = (int)mdlAddress - (int)dataAddress;
            header->_stringOffset = (int)stringTable[Name] + 4 - (int)dataAddress;

            header->_flag1     = _numTextures;
            header->_numLayers = _numLayers;
            header->_flag3     = _flag3;
            header->_flag4     = _flag4;
            header->_flag5     = _flag5;
            header->_flag6     = _flag6;
            header->_flag7     = _flag7;
            header->_flag8     = _flag8;
            header->_type      = _type;

            MDL0Data7Part4 *part4 = header->Part4;

            if (part4 != null)
            {
                ResourceGroup *group = part4->Group;
                group->_first = new ResourceEntry(0xFFFF, 0, 0, 0, 0);
                ResourceEntry *rEntry = group->First;

                for (int i = 0, x = 1; i < group->_numEntries; i++)
                {
                    MDL0Data7Part4Entry *entry = (MDL0Data7Part4Entry *)((int)group + (rEntry++)->_dataOffset);
                    ResourceEntry.Build(group, x++, entry, (BRESString *)stringTable[_part4Entries[i]]);
                    entry->ResourceStringAddress = stringTable[_part4Entries[i]] + 4;
                }
            }

            MDL0MatLayer *part3 = header->Part3;

            foreach (MDL0MaterialRefNode n in Children)
            {
                n.PostProcess(mdlAddress, part3++, stringTable);
            }
        }
        protected override bool OnInitialize()
        {
            //if (_name == null)
            _name = String.Format("Shader{0}", Index);

            //Attach to materials
            MDL0Node model   = Model;
            byte *   pHeader = (byte *)Header;

            if ((model != null) && (model._matList != null))
            {
                foreach (MDL0MaterialNode mat in model._matList)
                {
                    MDL0Material *mHeader = mat.Header;
                    if (((byte *)mHeader + mHeader->_shaderOffset) == pHeader)
                    {
                        mat._shader = this;
                        _materials.Add(mat);
                    }
                }
            }

            return(false);
        }