public DataSource(FileMap map) { Address = map.Address; Length = map.Length; Map = map; }
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); }
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(); } }
protected override void OnWrite(VoidPtr address) { }
public override void OnRebuild(VoidPtr address, int length, bool force) { *(blong *)address = _value; }
public override void OnRebuild(VoidPtr address, int length, bool force) { // Copy the data back to the address *(EventMatchDifficultyData *)address = data; }
public UnsafeBuffer(int size) { _data = Marshal.AllocHGlobal(size); _length = size; }
public static extern VoidPtr DefWindowProc(VoidPtr hWnd, uint uMsg, VoidPtr wParam, VoidPtr lParam);
public static extern bool DeleteDC(VoidPtr hdc);
public static extern VoidPtr CreateCompatibleDC(VoidPtr hdc);
public static extern VoidPtr CreateDC(string lpszDriver, string lpszDevice, string lpszOutput, VoidPtr lpInitData);
public static extern VoidPtr CreateCompatibleBitmap(VoidPtr hdc, int nWidth, int nHeight);
public static extern bool BitBlt(VoidPtr hObject, int nXDest, int nYDest, int nWidth, int nHeight, VoidPtr hObjSource, int nXSrc, int nYSrc, TernaryRasterOperations dwRop);
public void Close() { if (Map != null) { Map.Dispose(); Map = null; } Address = null; Length = 0; }
public static Bitmap Decode(VoidPtr addr, int w, int h, int mipLevel, WiiPixelFormat fmt) { return(Get(fmt).DecodeTexture(addr, w, h, mipLevel)); }
public static extern bool DeleteObject(VoidPtr hObject);
protected abstract void DecodeBlock(VoidPtr blockAddr, ARGBPixel *destAddr, int width);
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)); }
public static extern int FillRect(VoidPtr hDC, ref RECT lprc, VoidPtr hbr);
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); }
public static extern BkModeTypes GetBkMode(VoidPtr hdc);
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); } }
public static extern VoidPtr GetDC(VoidPtr hWnd);
public static ResourceNode FromAddress(ResourceNode parent, VoidPtr address, int length) { return(FromSource(parent, new DataSource(address, length))); }
public static extern VoidPtr GetDCEx(VoidPtr hwnd, VoidPtr hrgnclip, uint fdwOptions);
private void npy_byte_swap_common(VoidPtr vp, int size) { numpyAPI.npy_byte_swap_vector(vp, size, size); }
public static extern bool GetTextExtentPoint32(VoidPtr hdc, string lpString, int cbString, out Size lpSize);
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)); }
public static extern bool GetTextMetrics(VoidPtr hdc, out TEXTMETRIC lptm);
protected abstract void EncodeBlock(ARGBPixel *sPtr, VoidPtr blockAddr, int width);
public static extern int ReleaseDC(VoidPtr hwnd, VoidPtr hDC_Screen);
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; } }
public static extern bool ScrollDC(VoidPtr hDC, int dx, int dy, RECT* lprcScroll, RECT* lprcClip, VoidPtr hrgnUpdate, RECT* lprcUpdate);
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)); }
public static extern VoidPtr SelectObject(VoidPtr hdc, VoidPtr hObject);
public DataSource(VoidPtr addr, int len) : this(addr, len, CompressionType.None) { }
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); }
public static extern bool SetTextAlign(VoidPtr hdc, uint fmode);
public static void DefaultCastFunction(VoidPtr Src, VoidPtr Dest, int srclen, NpyArray srcArray, NpyArray destArray) { numpyAPI.DefaultCastFunction(Src, Dest, srclen, srcArray, destArray); return; }
public static extern bool SetTextAlign(VoidPtr hdc, TextAlignTypes fmode);
protected override void OnParse(VoidPtr address) { sListOffset *offset = (sListOffset *)address; _entries = Parse <EntryList <Unknown11EntryNode> >(offset->_startOffset, offset->_listCount); }
public static extern uint SetTextColor(VoidPtr hdc, uint crColor);
protected internal virtual void PostProcess(VoidPtr mdlAddress, VoidPtr dataAddress, StringTable stringTable) { }
public static extern bool TextOut(VoidPtr hdc, int nXStart, int nYStart, StringBuilder lpString, int cbString);
protected internal override void OnRebuild(VoidPtr address, int length, bool force) { base.OnRebuild(address, length, force); }
public static extern bool TextOut(VoidPtr hdc, int nXStart, int nYStart, char* lpString, int cbString);
public static ResourceNode GetRaw(VoidPtr address, int length) { return(GetRaw(new DataSource(address, length))); }
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()); }
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; } }
public static void Expand(YAY0 *header, VoidPtr dstAddr, int dstLen) { RunLength.ExpandYAY0(header, dstAddr, dstLen); }
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; }
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); }
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; }
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); }
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); } }
private void ClearRect(VoidPtr hdc, RECT rect) { WinAPI.FillRect(hdc, ref rect, hBackBrush); }
public DataSource(VoidPtr addr, int len) { Address = addr; Length = len; Map = null; }