Пример #1
0
 public DataSource(FileMap map)
 {
     Address = map.Address;
     Length = map.Length;
     Map = map;
 }
Пример #2
0
        internal static unsafe byte[] FromRSTM(RSTMHeader *rstm)
        {
            StrmDataInfo strmDataInfo = *rstm->HEADData->Part1;
            int          channels     = strmDataInfo._format._channels;

            if (strmDataInfo._format._encoding != (byte)WaveEncoding.ADPCM)
            {
                throw new NotImplementedException("FSTM export only supports ADPCM encoding.");
            }

            // Get section sizes from the BRSTM - BFSTM is such a similar format that we can assume the sizes will match.
            int rstmSize = 0x40;
            int infoSize = rstm->_headLength;
            int seekSize = rstm->_adpcLength;
            int dataSize = rstm->_dataLength;

            //Create byte array
            byte[] array = new byte[rstmSize + infoSize + seekSize + dataSize];

            fixed(byte *address = array)
            {
                //Get section pointers
                FSTMHeader *    fstm = (FSTMHeader *)address;
                FSTMINFOHeader *info = (FSTMINFOHeader *)((byte *)fstm + rstmSize);
                FSTMSEEKHeader *seek = (FSTMSEEKHeader *)((byte *)info + infoSize);
                FSTMDATAHeader *data = (FSTMDATAHeader *)((byte *)seek + seekSize);

                //Initialize sections
                fstm->Set(infoSize, seekSize, dataSize);
                info->Set(infoSize, channels);
                seek->Set(seekSize);
                data->Set(dataSize);

                //Set HEAD data
                info->_dataInfo = new FSTMDataInfo(strmDataInfo);

                //Create one ADPCMInfo for each channel
                IntPtr *        adpcData = stackalloc IntPtr[channels];
                FSTMADPCMInfo **pAdpcm   = (FSTMADPCMInfo **)adpcData;

                for (int i = 0; i < channels; i++)
                {
                    *(pAdpcm[i] = info->GetChannelInfo(i)) = new FSTMADPCMInfo(*rstm->HEADData->GetChannelInfo(i));
                }

                bshort *seekFrom = (bshort *)rstm->ADPCData->Data;
                bshort *seekTo   = (bshort *)seek->Data;

                for (int i = 0; i < seek->_length / 2 - 8; i++)
                {
                    *(seekTo++) = *(seekFrom++);
                }

                VoidPtr dataFrom = rstm->DATAData->Data;
                VoidPtr dataTo   = data->Data;

                Memory.Move(dataTo, dataFrom, (uint)data->_length);
            }

            return(array);
        }
Пример #3
0
 private void InitFont(Font font)
 {
     if (hFont)
     {
         WinAPI.DeleteObject(hFont);
     }
     hFont = font.ToHfont();
     if (hdcWindow)
     {
         WinAPI.SelectObject(hdcWindow, hFont);
         WinAPI.GetTextMetrics(hdcWindow, out textMetric);
         forceRedraw = true;
         Invalidate();
     }
 }
Пример #4
0
 protected override void OnWrite(VoidPtr address)
 {
 }
Пример #5
0
 public override void OnRebuild(VoidPtr address, int length, bool force)
 {
     *(blong *)address = _value;
 }
Пример #6
0
 public override void OnRebuild(VoidPtr address, int length, bool force)
 {
     // Copy the data back to the address
     *(EventMatchDifficultyData *)address = data;
 }
Пример #7
0
 public UnsafeBuffer(int size)
 {
     _data = Marshal.AllocHGlobal(size); _length = size;
 }
Пример #8
0
 public static extern VoidPtr DefWindowProc(VoidPtr hWnd, uint uMsg, VoidPtr wParam, VoidPtr lParam);
Пример #9
0
 public static extern bool DeleteDC(VoidPtr hdc);
Пример #10
0
 public static extern VoidPtr CreateCompatibleDC(VoidPtr hdc);
Пример #11
0
 public static extern VoidPtr CreateDC(string lpszDriver, string lpszDevice, string lpszOutput,
     VoidPtr lpInitData);
Пример #12
0
 public static extern VoidPtr CreateCompatibleBitmap(VoidPtr hdc, int nWidth, int nHeight);
Пример #13
0
 public static extern bool BitBlt(VoidPtr hObject, int nXDest, int nYDest, int nWidth,
     int nHeight, VoidPtr hObjSource, int nXSrc, int nYSrc, TernaryRasterOperations dwRop);
Пример #14
0
 public void Close()
 {
     if (Map != null) { Map.Dispose(); Map = null; }
     Address = null;
     Length = 0;
 }
Пример #15
0
 public static Bitmap Decode(VoidPtr addr, int w, int h, int mipLevel, WiiPixelFormat fmt)
 {
     return(Get(fmt).DecodeTexture(addr, w, h, mipLevel));
 }
Пример #16
0
 public static extern bool DeleteObject(VoidPtr hObject);
Пример #17
0
 protected abstract void DecodeBlock(VoidPtr blockAddr, ARGBPixel *destAddr, int width);
Пример #18
0
 public static extern bool ExtTextOut(VoidPtr hdc, int X, int Y, uint fuOptions,
     ref RECT lprc, string lpString, uint cbCount, int[] lpDx);
 public void Initialize(ResourceNode parent, VoidPtr address, int length)
 {
     Initialize(parent, new DataSource(address, length));
 }
Пример #20
0
 public static extern int FillRect(VoidPtr hDC, ref RECT lprc, VoidPtr hbr);
Пример #21
0
        public static VoidPtr GetArrayOfData(NPY_TYPES item_type, int dataLen, UInt64 FillData = 0, bool UseFillData = false, bool UseMaxValue = false)
        {
            VoidPtr data = null;

            switch (item_type)
            {
            case NPY_TYPES.NPY_BOOL:
            {
                bool[] bdata = new bool[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        bdata[i] = i % 2 != 0 ? true : false;
                    }
                    else
                    {
                        bdata[i] = i % 2 != 0 ? true : false;
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_BYTE:
            {
                sbyte[] bdata = new sbyte[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = sbyte.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (sbyte)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (sbyte)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_UBYTE:
            {
                byte[] bdata = new byte[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = byte.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (byte)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (byte)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }


            case NPY_TYPES.NPY_SHORT:
            {
                Int16[] bdata = new Int16[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = Int16.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (Int16)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (Int16)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_USHORT:
            {
                UInt16[] bdata = new UInt16[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = UInt16.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (UInt16)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (UInt16)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_INT32:
            {
                Int32[] bdata = new Int32[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = Int32.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (Int32)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (Int32)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_UINT32:
            {
                UInt32[] bdata = new UInt32[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = UInt32.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (UInt32)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (UInt32)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_LONG:
            {
                Int64[] bdata = new Int64[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = Int64.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (Int64)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (Int64)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_ULONG:
            {
                UInt64[] bdata = new UInt64[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = UInt64.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (UInt64)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (UInt64)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_FLOAT:
            {
                float[] bdata = new float[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = float.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (float)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (float)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_DOUBLE:
            {
                double[] bdata = new double[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = double.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (double)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (double)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_DECIMAL:
            {
                decimal[] bdata = new decimal[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        if (UseMaxValue)
                        {
                            bdata[i] = decimal.MaxValue;
                        }
                        else
                        {
                            bdata[i] = (decimal)FillData;
                        }
                    }
                    else
                    {
                        bdata[i] = (decimal)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            case NPY_TYPES.NPY_LONGLONG:
            case NPY_TYPES.NPY_ULONGLONG:
            {
                UInt64[] bdata = new UInt64[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        bdata[i] = (UInt64)FillData;
                    }
                    else
                    {
                        bdata[i] = (UInt64)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            // not sure about these yet.  Not really supported
            case NPY_TYPES.NPY_DATETIME:
            case NPY_TYPES.NPY_TIMEDELTA:
            {
                UInt64[] bdata = new UInt64[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        bdata[i] = (UInt64)FillData;
                    }
                    else
                    {
                        bdata[i] = (UInt64)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }


            // not sure about these yet.  Not really supported
            case NPY_TYPES.NPY_LONGDOUBLE:
            case NPY_TYPES.NPY_CFLOAT:
            case NPY_TYPES.NPY_CDOUBLE:
            case NPY_TYPES.NPY_CLONGDOUBLE:
            {
                UInt64[] bdata = new UInt64[dataLen];

                for (int i = 0; i < bdata.Length; i++)
                {
                    if (UseFillData)
                    {
                        bdata[i] = (UInt64)FillData;
                    }
                    else
                    {
                        bdata[i] = (UInt64)(i + ArrayDataAdjust);
                    }
                }

                data = new VoidPtr(bdata);
                break;
            }

            default:
                throw new Exception(string.Format("GetArrayOfData: Unexpected item_type {0}", item_type));
            }

            data.type_num = item_type;
            return(data);
        }
Пример #22
0
 public static extern BkModeTypes GetBkMode(VoidPtr hdc);
Пример #23
0
        public override void OnRebuild(VoidPtr address, int length, bool force)
        {
            CollisionHeader *header = (CollisionHeader *)address;

            *header = new CollisionHeader(_pointCount, _planeCount, _objects.Count, _unk1);

            BVec2 *    pPoint = header->Points;
            ColPlane * pPlane = header->Planes;
            ColObject *pObj   = header->Objects;

            int iPoint = 0, iPlane = 0;
            int lind, rind, llink, rlink, tmp;
            int cPoint, cPlane;

            CollisionPlane current, next;
            CollisionLink  link;

            foreach (CollisionObject obj in _objects)
            {
                //Sets bounds and entry indices
                obj.Prepare();

                cPoint = iPoint;
                cPlane = iPlane;
                foreach (CollisionPlane plane in obj._planes)
                {
                    if (plane._encodeIndex != -1)
                    {
                        continue;
                    }
                    current = next = plane;

Top:
                    //Update variables, moving to next plane and links
                    llink   = current._encodeIndex;
                    current = next;
                    next    = null;
                    rlink   = -1;

                    //Get left point index, and encode where necessary
                    if ((link = current._linkLeft)._encodeIndex == -1)
                    {
                        pPoint[link._encodeIndex = lind = iPoint++] = link._rawValue;
                    }
                    else
                    {
                        lind = link._encodeIndex;
                    }

                    //Get right point index and encode.
                    if ((link = current._linkRight)._encodeIndex == -1)
                    {
                        pPoint[link._encodeIndex = rind = iPoint++] = link._rawValue;
                    }
                    else
                    {
                        rind = link._encodeIndex;
                    }

                    //Right-link planes by finding next available
                    if (link != null)
                    {
                        foreach (CollisionPlane p in link._members)
                        {
                            if ((p == current) || (p._linkLeft != link))
                            {
                                continue; //We only want to go left-to-right!
                            }
                            //Determine if entry has been encoded yet
                            if ((tmp = p._encodeIndex) != -1)
                            {
                                if (pPlane[tmp]._link1 != -1)
                                {
                                    continue; //Already linked, try again
                                }
                                else
                                {
                                    pPlane[rlink = tmp]._link1 = (short)iPlane; //Left link, which means the end!
                                }
                            }
                            else
                            {
                                next  = p;
                                rlink = iPlane + 1;
                            }

                            break;
                        }
                    }

                    //Create entry
                    pPlane[current._encodeIndex = iPlane++] = new ColPlane(lind, rind, llink, rlink, current._type, current._flags2, current._flags, current._material);

                    //Traverse
                    if (next != null)
                    {
                        goto Top;
                    }
                }

                *pObj++ = new ColObject(cPlane, iPlane - cPlane, cPoint, iPoint - cPoint, obj._boxMin, obj._boxMax, obj._modelName, obj._boneName,
                                        obj._unk1, obj._unk2, obj._unk3, obj._flags, obj._unk5, obj._unk6, obj._boneIndex);
            }
        }
Пример #24
0
 public static extern VoidPtr GetDC(VoidPtr hWnd);
Пример #25
0
 public static ResourceNode FromAddress(ResourceNode parent, VoidPtr address, int length)
 {
     return(FromSource(parent, new DataSource(address, length)));
 }
Пример #26
0
 public static extern VoidPtr GetDCEx(VoidPtr hwnd, VoidPtr hrgnclip, uint fdwOptions);
Пример #27
0
 private void npy_byte_swap_common(VoidPtr vp, int size)
 {
     numpyAPI.npy_byte_swap_vector(vp, size, size);
 }
Пример #28
0
 public static extern bool GetTextExtentPoint32(VoidPtr hdc, string lpString, int cbString, out Size lpSize);
Пример #29
0
 private void ResizeBackBuffer(Size newSize)
 {
     WinAPI.DeleteObject(hBackBuffer);
     hBackBuffer = WinAPI.CreateCompatibleBitmap(hdcWindow, newSize.Width, newSize.Height);
     backBufferSize = newSize;
     WinAPI.SelectObject(hdcBackBuffer, hBackBuffer);
     ClearRect(hdcBackBuffer, RECT.FromSize(newSize));
 }
Пример #30
0
 public static extern bool GetTextMetrics(VoidPtr hdc, out TEXTMETRIC lptm);
Пример #31
0
 protected abstract void EncodeBlock(ARGBPixel *sPtr, VoidPtr blockAddr, int width);
Пример #32
0
 public static extern int ReleaseDC(VoidPtr hwnd, VoidPtr hDC_Screen);
Пример #33
0
 public virtual Bitmap DecodeREFTTextureIndexed(VoidPtr addr, int w, int h, ColorPalette palette, int mipLevel, WiiPixelFormat fmt)
 {
     _workingPalette = palette;
     try { return(Decode(addr, w, h, mipLevel, fmt)); }
     finally { _workingPalette = null; }
 }
Пример #34
0
 public static extern bool ScrollDC(VoidPtr hDC, int dx, int dy, RECT* lprcScroll, RECT* lprcClip, VoidPtr hrgnUpdate, RECT* lprcUpdate);
Пример #35
0
 public static Bitmap DecodeREFTIndexed(VoidPtr addr, int w, int h, ColorPalette palette, int mipLevel, WiiPixelFormat fmt)
 {
     return(Get(fmt).DecodeREFTTextureIndexed(addr, w, h, palette, mipLevel, fmt));
 }
Пример #36
0
 public static extern VoidPtr SelectObject(VoidPtr hdc, VoidPtr hObject);
 public DataSource(VoidPtr addr, int len) : this(addr, len, CompressionType.None)
 {
 }
Пример #38
0
 public static extern int SetBkMode(VoidPtr hdc, BkModeTypes iBkMode);
 //Overridden by derived nodes in order to rebuild children.
 //Size is the value returned by OnCalculateSize (or _calcSize)
 //Node MUST dispose of and assign both repl sources before exiting. (Not exactly, see Rebuild())
 public virtual void OnRebuild(VoidPtr address, int length, bool force)
 {
     MoveRawUncompressed(address, length);
 }
Пример #40
0
 public static extern bool SetTextAlign(VoidPtr hdc, uint fmode);
Пример #41
0
 public static void DefaultCastFunction(VoidPtr Src, VoidPtr Dest, int srclen, NpyArray srcArray, NpyArray destArray)
 {
     numpyAPI.DefaultCastFunction(Src, Dest, srclen, srcArray, destArray);
     return;
 }
Пример #42
0
 public static extern bool SetTextAlign(VoidPtr hdc, TextAlignTypes fmode);
Пример #43
0
        protected override void OnParse(VoidPtr address)
        {
            sListOffset *offset = (sListOffset *)address;

            _entries = Parse <EntryList <Unknown11EntryNode> >(offset->_startOffset, offset->_listCount);
        }
Пример #44
0
 public static extern uint SetTextColor(VoidPtr hdc, uint crColor);
Пример #45
0
 protected internal virtual void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable)
 {
 }
Пример #46
0
 public static extern bool TextOut(VoidPtr hdc, int nXStart, int nYStart, StringBuilder lpString, int cbString);
Пример #47
0
 protected internal override void OnRebuild(VoidPtr address, int length, bool force)
 {
     base.OnRebuild(address, length, force);
 }
Пример #48
0
 public static extern bool TextOut(VoidPtr hdc, int nXStart, int nYStart, char* lpString, int cbString);
Пример #49
0
 public static ResourceNode GetRaw(VoidPtr address, int length)
 {
     return(GetRaw(new DataSource(address, length)));
 }
Пример #50
0
        public static MMLCommand[] Parse(VoidPtr address)
        {
            List <MMLCommand> commands = new List <MMLCommand>();

            Mml   cmd;
            byte *addr = (byte *)address;

            while ((cmd = (Mml)(*addr++)) != Mml.MML_FIN)
            {
                MMLCommand mml = new MMLCommand(cmd);
                if (cmd == Mml.MML_WAIT || cmd == Mml.MML_PRG)
                {
                    switch ((SeqArgType)(*addr++))
                    {
                    case SeqArgType.SEQ_ARG_NONE:
                        addr++;
                        break;

                    case SeqArgType.SEQ_ARG_RANDOM:
                        break;

                    case SeqArgType.SEQ_ARG_S16:
                        break;

                    case SeqArgType.SEQ_ARG_U8:
                        break;

                    case SeqArgType.SEQ_ARG_VARIABLE:
                        break;

                    case SeqArgType.SEQ_ARG_VMIDI:
                        break;
                    }
                }
                else if (cmd == Mml.MML_EX_COMMAND)
                {
                    switch ((MmlEx)(*addr++))
                    {
                    case MmlEx.MML_SETVAR: break;

                    case MmlEx.MML_ADDVAR: break;

                    case MmlEx.MML_SUBVAR: break;

                    case MmlEx.MML_MULVAR: break;

                    case MmlEx.MML_DIVVAR: break;

                    case MmlEx.MML_SHIFTVAR: break;

                    case MmlEx.MML_RANDVAR: break;

                    case MmlEx.MML_ANDVAR: break;

                    case MmlEx.MML_ORVAR: break;

                    case MmlEx.MML_XORVAR: break;

                    case MmlEx.MML_NOTVAR: break;

                    case MmlEx.MML_MODVAR: break;

                    case MmlEx.MML_CMP_EQ: break;

                    case MmlEx.MML_CMP_GE: break;

                    case MmlEx.MML_CMP_GT: break;

                    case MmlEx.MML_CMP_LE: break;

                    case MmlEx.MML_CMP_LT: break;

                    case MmlEx.MML_CMP_NE: break;

                    case MmlEx.MML_USERPROC: break;
                    }
                    addr += 3;
                }
            }
            commands.Add(new MMLCommand(Mml.MML_FIN, 0));
            return(commands.ToArray());
        }
Пример #51
0
        public void Set(int size, int channels, WaveEncoding encoding)
        {
            RuintList *list;
            VoidPtr    offset     = _entries.Address;
            int        dataOffset = 0x60 + (channels * 8);

            _tag  = Tag;
            _size = size;

            //Set entry offsets
            _entries.Entries[0] = 0x18;
            _entries.Entries[1] = 0x4C;
            _entries.Entries[2] = 0x5C;

            //Audio info
            //HEADPart1* part1 = Part1;

            //Set single channel info
            list = Part2;
            list->_numEntries._data = 1; //Number is little-endian
            list->Entries[0]        = 0x58;
            // TODO: This is not actually AudioFormatInfo. Set it as a buint instead.
            *(AudioFormatInfo *)list->Get(offset, 0) =
                channels == 1 ? new AudioFormatInfo(1, 0, 0, 0) : new AudioFormatInfo(2, 0, 1, 0);

            //Set adpcm infos
            list = Part3;
            list->_numEntries._data = channels; //little-endian
            for (int i = 0; i < channels; i++)
            {
                //Set initial pointer
                list->Entries[i] = dataOffset;

                if (encoding == WaveEncoding.ADPCM)
                {
                    //Set embedded pointer
                    *(ruint *)(offset + dataOffset) = dataOffset + 8;
                    dataOffset += 8;

                    //Set info
                    //*(ADPCMInfo*)(offset + dataOffset) = info[i];
                    dataOffset += ADPCMInfo.Size;

                    //Set padding
                    //*(short*)(offset + dataOffset) = 0;
                    //dataOffset += 2;
                }
                else
                {
                    //Set embedded pointer
                    *(ruint *)(offset + dataOffset) = 0;
                    dataOffset += 8;
                }
            }

            //Fill remaining
            int *p = (int *)(offset + dataOffset);

            for (dataOffset += 8; dataOffset < size; dataOffset += 4)
            {
                *p++ = 0;
            }
        }
Пример #52
0
 public static void Expand(YAY0 *header, VoidPtr dstAddr, int dstLen)
 {
     RunLength.ExpandYAY0(header, dstAddr, dstLen);
 }
Пример #53
0
 public lFileMap(VoidPtr hFile, FileMapProtect protect, uint offset, uint length)
 {
     Linux.MMapProtect mProtect = (protect == FileMapProtect.ReadWrite) ? Linux.MMapProtect.Read | Linux.MMapProtect.Write : Linux.MMapProtect.Read;
     _addr   = Linux.mmap(null, length, mProtect, Linux.MMapFlags.Shared, hFile, offset);
     _length = (int)length;
 }
Пример #54
0
        protected override void OnPopulate()
        {
            RSARNode    rsar     = RSARNode;
            SYMBHeader *symb     = null;
            RuintList * bankList = null;
            //INFOBankEntry** soundIndices = null;
            VoidPtr soundOffset = null;
            //INFOBankEntry* sEntry;
            RBNKGroupNode    g;
            RBNKHeader *     rwsd = Header;
            RBNK_DATAHeader *data = rwsd->Data;
            //RWSD_WAVEHeader* wave = rwsd->Wave;
            RuintList *list = &data->_list;
            //RuintList* waveList = &wave->_list;
            int count = list->_numEntries;

            //Get sound info from RSAR (mainly for names)
            if (rsar != null)
            {
                symb        = rsar.Header->SYMBBlock;
                soundOffset = &rsar.Header->INFOBlock->_collection;
                bankList    = rsar.Header->INFOBlock->Banks;
                //soundIndices = (INFOBankEntry**)Marshal.AllocHGlobal(count * 4);

                //int sIndex = 0;
                //int soundCount = soundList->_numEntries;
                //for (int i = 0; i < soundCount; i++)
                //    if ((sEntry = (INFOBankEntry*)soundList->Get(soundOffset, i))->_fileId == _fileIndex)
                //        soundIndices[((INFOSoundPart2*)sEntry->GetPart2(soundOffset))->_soundIndex] = sEntry;
            }
            (g = new RBNKGroupNode()).Initialize(this, Header->Data, Header->_dataLength);
            for (int i = 0; i < count; i++)
            {
                RBNK_DATAEntry *entry = (RBNK_DATAEntry *)list->Get(list, i);
                RBNKDataNode    node  = new RBNKDataNode();
                node._offset = list;
                node.Initialize(g, entry, 0);

                //Attach from INFO block
                //if (soundIndices != null)
                //{
                //    sEntry = soundIndices[i];
                //    node._name = symb->GetStringEntry(sEntry->_stringId);
                //}
            }

            //if (soundIndices != null)
            //    Marshal.FreeHGlobal((IntPtr)soundIndices);

            //Get labels
            RSARNode parent;
            int      count2 = Header->Data->_list._numEntries;

            if ((_labels == null) && ((parent = RSARNode) != null))
            {
                _labels = new LabelItem[count2];// new string[count];

                //Get them from RSAR
                SYMBHeader *symb2 = parent.Header->SYMBBlock;
                INFOHeader *info  = parent.Header->INFOBlock;

                VoidPtr    offset    = &info->_collection;
                RuintList *bankList2 = info->Banks;
                count2 = bankList2->_numEntries;

                //INFOBankEntry* entry;
                //for (int i = 0; i < count2; i++)
                //    if ((entry = (INFOBankEntry*)soundList2->Get(offset, i))->_fileId == _fileIndex)
                //        _labels[((INFOSoundPart2*)entry->GetPart2(offset))->_soundIndex] = new LabelItem() { Tag = i, String = symb2->GetStringEntry(entry->_stringId) };
            }

            new RBNKGroupNode().Initialize(this, Header->Wave, Header->_waveLength);
        }
Пример #55
0
 public int ReadSamples(VoidPtr destAddr, int numSamples)
 {
     return(BaseStream.ReadSamples(destAddr, numSamples));
 }
        protected override void OnWrite(VoidPtr address)
        {
            VoidPtr addr = address;

            foreach (ArticleEntry b in Children)
            {
                b._buildHeader = false;
                b.Rebuild(addr, b._childLength, true);
                addr += b._childLength;
            }

            VoidPtr start = addr;

            foreach (ArticleEntry b in Children)
            {
                b._rebuildAddr = addr;

                Article *article = (Article *)addr;

                article->_id       = b.id;
                article->_boneID   = b.charBone;
                article->_arcGroup = b.articleBone;

                article->_actionsStart        = b.aStart;
                article->_actionFlagsStart    = b.aFlags;
                article->_subactionFlagsStart = b.sFlags;
                article->_subactionMainStart  = b.sMStart;
                article->_subactionGFXStart   = b.sGStart;
                article->_subactionSFXStart   = b.sSStart;
                article->_modelVisibility     = b.visStart;
                article->_collisionData       = b.off1;
                article->_unknownD2           = b.off2;
                article->_unknownD3           = b.off3;

                bint *ext = (bint *)((VoidPtr)article + 52);
                ext[0] = (b._subActions == null ? 0 : b._subActions.Children.Count);

                //Add all header offsets
                bint *off = (bint *)(addr + 12);
                for (int i = 0; i < 10 + b._extraOffsets.Count; i++)
                {
                    if (off[i] > 1480 && off[i] < _root.dataSize)
                    {
                        b._lookupOffsets.Add(&off[i]);
                    }
                }

                _lookupOffsets.AddRange(b._lookupOffsets);

                addr += b._entryLength;
            }

            FDefListOffset *header = (FDefListOffset *)addr;

            _rebuildAddr = header;

            if (Children.Count > 0)
            {
                header->_startOffset = (int)start - (int)RebuildBase;
                _lookupOffsets.Add(header->_startOffset.Address);
            }

            header->_listCount = Children.Count;
        }
Пример #57
0
 protected override void OnHandleCreated(EventArgs e)
 {
     base.OnHandleCreated(e);
     hWindow = Handle;
     hdcWindow = WinAPI.GetDC(hWindow);
     Debug.Assert(hdcWindow, "Unable to get DC");
     InitFont(Font);
     hdcBackBuffer = WinAPI.CreateCompatibleDC(hdcWindow);
     Debug.Assert(hdcBackBuffer, "Unable to create Compatible DC");
     backBufferSize = GetGranulatedClientSize();
     hBackBuffer = WinAPI.CreateCompatibleBitmap(hdcWindow, backBufferSize.Width, backBufferSize.Height);
     Debug.Assert(hBackBuffer, "Unable to create Compatible Bitmap");
     hBackBrush = WinAPI.GetStockObject(StockObjects.BLACK_BRUSH);
     Debug.Assert(hBackBrush, "Unable to create SolidBrush");
     hSelectionBrush = WinAPI.CreateSolidBrush(ConsoleColors.DarkGray);
     Debug.Assert(hSelectionBrush, "Unable to create SolidBrush");
     WinAPI.SelectObject(hdcBackBuffer, hBackBuffer);
     ClearRect(hdcBackBuffer, RECT.FromSize(backBufferSize));
     WinAPI.SetBkMode(hdcBackBuffer, WinAPI.BkModeTypes.OPAQUE);
     WinAPI.SetBkColor(hdcBackBuffer, ConsoleColors.Black);
 }
Пример #58
0
        public virtual FileMap EncodeREFTTexture(Bitmap src, int mipLevels, WiiPaletteFormat format, bool usePalette)
        {
            int w = src.Width, h = src.Height;
            int bw = BlockWidth, bh = BlockHeight;
            //int aw = w.Align(bw), ah = h.Align(bh);
            ColorPalette pal = src.Palette;

            PixelFormat fmt = src.IsIndexed() ? src.PixelFormat : PixelFormat.Format32bppArgb;

            //int fileSize = GetMipOffset(w, h, mipLevels + 1) + 0x20;
            FileMap fileView = FileMap.FromTempFile(GetFileSize(w, h, mipLevels, true) + (usePalette ? (pal.Entries.Length * 2) : 0));

            //FileMap fileView = FileMap.FromTempFile(fileSize);
            try
            {
                //Build REFT image header
                REFTData *header = (REFTData *)fileView.Address;
                *         header = new REFTData((ushort)w, (ushort)h, (byte)RawFormat);
                header->_imagelen = (uint)fileView.Length - 0x20;

                int     sStep    = bw * Image.GetPixelFormatSize(fmt) / 8;
                int     dStep    = bw * bh * BitsPerPixel / 8;
                VoidPtr baseAddr = (byte *)header + 0x20;

                using (DIB dib = DIB.FromBitmap(src, bw, bh, fmt))
                    for (int i = 1; i <= mipLevels; i++)
                    {
                        EncodeLevel(baseAddr, dib, src, dStep, sStep, i);
                    }

                if (usePalette)
                {
                    int count = pal.Entries.Length;

                    header->_colorCount = (ushort)count;
                    header->_pltFormat  = (byte)format;

                    switch (format)
                    {
                    case WiiPaletteFormat.IA8:
                    {
                        IA8Pixel *dPtr = (IA8Pixel *)header->PaletteData;
                        for (int i = 0; i < count; i++)
                        {
                            dPtr[i] = (IA8Pixel)pal.Entries[i];
                        }
                        break;
                    }

                    case WiiPaletteFormat.RGB565:
                    {
                        wRGB565Pixel *dPtr = (wRGB565Pixel *)header->PaletteData;
                        for (int i = 0; i < count; i++)
                        {
                            dPtr[i] = (wRGB565Pixel)pal.Entries[i];
                        }
                        break;
                    }

                    case WiiPaletteFormat.RGB5A3:
                    {
                        wRGB5A3Pixel *dPtr = (wRGB5A3Pixel *)header->PaletteData;
                        for (int i = 0; i < count; i++)
                        {
                            dPtr[i] = (wRGB5A3Pixel)pal.Entries[i];
                        }
                        break;
                    }
                    }
                }

                return(fileView);
            }
            catch (Exception x)
            {
                //MessageBox.Show(x.ToString());
                fileView.Dispose();
                return(null);
            }
        }
Пример #59
0
 private void ClearRect(VoidPtr hdc, RECT rect)
 {
     WinAPI.FillRect(hdc, ref rect, hBackBrush);
 }
Пример #60
0
 public DataSource(VoidPtr addr, int len)
 {
     Address = addr;
     Length = len;
     Map = null;
 }