public static byte[] GenerateBFF2(byte[] palette, byte[] data, CGeneric.Compression compressionMethod, int sizeX, int sizeY, string bffName) { //generate header //--> determine GreenAlpha and palette size byte greenAlphaIndex = 0; if (palette.Length > 0) { greenAlphaIndex = CTextureManager.GetGreenAlphaValueIndex(palette, compressionMethod); } //make almost random compressed value.. (10)(because not enought information about it) //set displayedWidth equal pixel width (because not enought information about it) byte[] sizeXB = CGeneric.ConvertIntToByteArray16bits(sizeX); byte[] sizeYB = CGeneric.ConvertIntToByteArray16bits(sizeY); byte[] name = CGeneric.ConvertStringToByteArray(bffName); byte[] nbColors = new byte[0]; if (palette.Length > 0) { nbColors = CGeneric.ConvertIntToByteArray(palette.Length / CTextureManager.GetBytePerPixel(compressionMethod)); } byte[] bff2header = SetHeader(compressionMethod, greenAlphaIndex, 0xE, sizeXB, sizeXB, sizeYB, name, nbColors); //concatenate header, palette and compressed data byte[] finalData = new byte[bff2header.Length + palette.Length + data.Length]; Array.Copy(bff2header, 0, finalData, 0, bff2header.Length); if (palette.Length > 0) { Array.Copy(palette, 0, finalData, bff2header.Length, palette.Length); } Array.Copy(data, 0, finalData, bff2header.Length + palette.Length, data.Length); return(finalData); }
private int ChunkTextObject(byte[] data, int nbTextObject, int indexDataStart) { byte[] lengthHeader = new byte[4]; byte[] lengthText = new byte[4]; int lengthHeaderInt; int lengthTextInt; int totalSize = 0; for (int i = 0; i < nbTextObject; i++) { // get the length of the header text object Array.Copy(data, indexDataStart, lengthHeader, 0, lengthHeader.Length); lengthHeaderInt = CSBF1TextObject.GetHeaderLength(CGeneric.ConvertByteArrayToInt(lengthHeader)); //grab the size of the text (add 4 for the header (size text) and determine length of text (multiply per 2)) Array.Copy(data, indexDataStart + lengthHeaderInt, lengthText, 0, lengthText.Length); lengthTextInt = lengthText.Length + CGeneric.ConvertByteArrayToInt(lengthText) * 2; //store the new item byte[] dataTextObject = new byte[lengthHeaderInt + lengthTextInt]; Array.Copy(data, indexDataStart, dataTextObject, 0, dataTextObject.Length); textObjectList.Add(new CSBF1TextObject(dataTextObject, lengthHeaderInt, lengthTextInt)); //increment totalSize and indexStart indexDataStart += lengthHeaderInt + lengthTextInt; totalSize += lengthHeaderInt + lengthTextInt; } return(totalSize); }
private static (byte[] palette, byte[] data) ConvertRGBAtoMax16Colors(byte[] texture) { //construct palette and use it. List <Color> colors = ExtractPaletteFromByteArray(texture); //first array for palette color byte[] palette = new byte[colors.Count * 4]; //second array for palette data byte[] finalArray = new byte[texture.Length / 8]; // write palette for (int i = 0; i < colors.Count(); i++) { palette[i * 4] = colors[i].R; palette[i * 4 + 1] = colors[i].G; palette[i * 4 + 2] = colors[i].B; palette[i * 4 + 3] = colors[i].A; } int index = 0; byte nibble1; byte nibble2; // write data with palette information for (int i = 0; i < texture.Length; i += 8) { nibble1 = GetIndexFromPalette(colors, Color.FromArgb(texture[i + 3], texture[i], texture[i + 1], texture[i + 2])); nibble2 = GetIndexFromPalette(colors, Color.FromArgb(texture[i + 7], texture[i + 4], texture[i + 5], texture[i + 6])); finalArray[index] = CGeneric.NibbleToByte(nibble1, nibble2); index++; } return(palette, finalArray); }
private void WriteListHeader <T>(ref FileStream fs, ref int indexData, List <T> listOfressource) where T : AbsRessource { for (int index = 0; index < listOfressource.Count(); index++) { //write size fs.Write(CGeneric.ConvertIntToByteArray(listOfressource[index].GetRawData().Length), 0, 4); // write index start fs.Write(CGeneric.ConvertIntToByteArray(indexData), 0, 4); //write name of FIB (BIF Name) byte[] nameBIF = System.Text.Encoding.UTF8.GetBytes(listOfressource[index].GetRessourceName()); fs.Write(nameBIF, 0, nameBIF.Length); //fill free space (of name) by 0 for (int freeSpace = 0; freeSpace < 16 - nameBIF.Length; freeSpace++) { fs.WriteByte(0); } //if data is not pair, add a FF for to be sure it's pair... (because !) if (listOfressource[index].GetRawData().Length % 2 == 1) { indexData++; } indexData += listOfressource[index].GetRawData().Length; } }
public void AddNewTextObject(bool sameScene) { //get the last element if (textObjectList.Count > 0) { var LastText = textObjectList[textObjectList.Count - 1]; //add one to ID and take his group int textId = LastText.id + 1; int groupText = LastText.group; //if the text is independant if (!sameScene) { textId += 0x64; groupText += 1; } //create the new text object textObjectList.Add(new CSBF1TextObject(CGeneric.ConvertIntToByteArray(textId), groupText)); } else { textObjectList.Add(new CSBF1TextObject(CGeneric.ConvertIntToByteArray(0), 0)); } }
private static byte GetByteForCompression(int qtReaded, int qtRepeated) { byte nib1 = 0; switch (qtReaded) { case 1: nib1 = 0x8; break; case int n when(n == 2 || n == 3): nib1 = 0xC; break; case int n when(n == 4 || n == 5): nib1 = 0xD; break; case int n when(n == 6 || n == 7): nib1 = 0xE; break; case int n when(n == 8 || n == 9): nib1 = 0xF; break; } byte nib2 = (byte)(qtRepeated - 2); if (qtReaded % 2 == 1 && nib1 != 0x8) { nib2 += 8; } return(CGeneric.NibbleToByte(nib1, nib2)); }
private int ChunkDynamicObject(byte[] data, int nbDynamicObject, int indexDataStart) { byte[] lengthData = new byte[4]; int lengthDataInt; int totalSize = 0; for (int i = 0; i < nbDynamicObject; i++) { // get the length of the dynamic object Array.Copy(data, indexDataStart, lengthData, 0, lengthData.Length); lengthDataInt = CSBF1DynamicObject.GetHeaderLength(CGeneric.ConvertByteArrayToInt(lengthData)); //create the array to add the object byte[] dataDynamicObject = new byte[lengthDataInt]; //create the new dynamicObject item Array.Copy(data, indexDataStart, dataDynamicObject, 0, dataDynamicObject.Length); dynamicObjectList.Add(new CSBF1DynamicObject(dataDynamicObject)); //increment totalSize and indexStart indexDataStart += lengthDataInt; totalSize += lengthDataInt; } return(totalSize); }
public CSBF1(Byte[] rawData, Byte[] ressourceName) : base(rawData, ressourceName) { //grab nb ressources used in scene int nbTextureScene = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, 4, 4)); //grab names of texture used (bif list) bifList = new List <byte[]>(); for (int i = 0; i < nbTextureScene; i++) { byte[] tmpArray = new byte[16]; Array.Copy(rawData, 8 + i * 16, tmpArray, 0, tmpArray.Length); bifList.Add(tmpArray); } //grab index number of scene int headerSize = 12 + bifList.Count * 0x10; int nbScene = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, headerSize - 4, 4)); //send the data without SBF header for chuncking data.. byte[] dataWithoutHeader = new byte[rawData.Length - headerSize]; Array.Copy(rawData, headerSize, dataWithoutHeader, 0, dataWithoutHeader.Length); SetChunk(dataWithoutHeader, nbScene); }
public CSBF1TextureManagement(int id, int index) { byte[] newTexture = new byte[28]; Array.Copy(CGeneric.ConvertIntToByteArray(id), 0, newTexture, 16, 4); Array.Copy(CGeneric.ConvertIntToByteArray(-1), 0, newTexture, 20, 4); Array.Copy(CGeneric.ConvertIntToByteArray(index), 0, newTexture, 24, 4); rawData = newTexture; decomposeHeader(); }
public List <string> GetBifList() { var list = new List <String>(); foreach (byte[] element in bifList) { list.Add(CGeneric.ConvertByteArrayToString(element)); } return(list); }
public void Init() { //init header... // take 2 byte : for the fist byte keep only 4 last bit and for the second keep only the 4 first.. byte b1 = rawData[17]; byte b2 = rawData[18]; b1 %= 16; b1 <<= 4; b2 /= 16; b1 += b2; headerBFF2.transparencyPixelIndex = b1; headerBFF2.displayLength = rawData[8]; // check if the data is compressed and if data had indexed color headerBFF2.isCompressedTexture = (rawData[18] % 16 > 7) ? true : false; //copy basic informations.. headerBFF2.textureType = rawData[19]; headerBFF2.nameLength = rawData[35]; headerBFF2.isIndexedColor = (headerBFF2.textureType == 0x32 || headerBFF2.textureType == 0x33) ? true : false; headerBFF2.textureWidth = new byte[2]; headerBFF2.textureHeight = new byte[2]; headerBFF2.name = new byte[headerBFF2.nameLength]; headerBFF2.bytePerPixel = (byte)CTextureManager.GetBytePerPixel((CGeneric.Compression)headerBFF2.textureType); Array.Copy(rawData, 22, headerBFF2.textureWidth, 0, 2); Array.Copy(rawData, 26, headerBFF2.textureHeight, 0, 2); Array.Copy(rawData, 36, headerBFF2.name, 0, headerBFF2.nameLength); //remove last not necessary character if (headerBFF2.name[headerBFF2.nameLength - 1] == 0) { headerBFF2.name = new byte[headerBFF2.nameLength - 1]; Array.Copy(rawData, 36, headerBFF2.name, 0, headerBFF2.nameLength - 1); } headerBFF2.sizeX = CGeneric.ConvertByteArrayToInt(headerBFF2.textureWidth); headerBFF2.sizeY = CGeneric.ConvertByteArrayToInt(headerBFF2.textureHeight); //extract palette int startingData = 0x24 + headerBFF2.nameLength; if (headerBFF2.isIndexedColor) { ExtractPalette(startingData); startingData += headerBFF2.palette.Length + headerBFF2.paletteSize.Length; } headerBFF2.dataCompressed = new Byte[rawData.Length - startingData]; Array.Copy(rawData, startingData, headerBFF2.dataCompressed, 0, headerBFF2.dataCompressed.Length); }
private void ExtractPalette(int indexPalette) { //get palette size headerBFF2.paletteSize = new Byte[4]; Array.Copy(rawData, indexPalette, headerBFF2.paletteSize, 0, headerBFF2.paletteSize.Length); //fill palette data int paletteSize1 = CGeneric.ConvertByteArrayToInt(headerBFF2.paletteSize); headerBFF2.palette = new Byte[paletteSize1 * headerBFF2.bytePerPixel]; Array.Copy(rawData, indexPalette + headerBFF2.paletteSize.Length, headerBFF2.palette, 0, headerBFF2.palette.Length); }
public void Add3FIB(string name) { //set name and header initial data byte[] byteName = CGeneric.ConvertStringToByteArray(name); byte[] rawData = new byte[] { 0x33, 0x46, 0x49, 0x42, 8, 1, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, (byte)byteName.Length, 0, 0, 0 }; rawData = rawData.Concat(byteName).ToArray(); //add .fib to the end, and init the 3fib. C3FIB new3Fib = new C3FIB(rawData, byteName.Concat(new Byte[] { 0x2E, 0x42, 0x49, 0x46 }).ToArray()); new3Fib.Init(); fibList.Add(new3Fib); }
public byte[] GetRawData() { int flags = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, 0, 4)); //set unknown bit values //CGeneric.SetBitInInt(ref flags, 1, true); //Array.Copy(CGeneric.ConvertIntToByteArray(flags), 0, rawData, 0, 4); return(rawData); }
public byte[] GetRawData() { int newHeaderDataSize = 28; if (this.transparencybit) { newHeaderDataSize += 4; } if (this.extra2) { newHeaderDataSize += 8; } byte[] newHeaderData = new byte[newHeaderDataSize]; int flags = 0; //set extra bit value CGeneric.SetBitInInt(ref flags, 22, this.transparencybit); CGeneric.SetBitInInt(ref flags, 26, this.extra2); //set unknown bit values CGeneric.SetBitInInt(ref flags, 19, this.bit19); CGeneric.SetBitInInt(ref flags, 20, this.bit20); CGeneric.SetBitInInt(ref flags, 21, this.bit21); CGeneric.SetBitInInt(ref flags, 23, this.bit23); CGeneric.SetBitInInt(ref flags, 24, this.bit24); CGeneric.SetBitInInt(ref flags, 25, this.bit25); CGeneric.SetBitInInt(ref flags, 27, this.bit27); CGeneric.SetBitInInt(ref flags, 28, this.bit28); CGeneric.SetBitInInt(ref flags, 29, this.bit29); CGeneric.SetBitInInt(ref flags, 30, this.bit30); CGeneric.SetBitInInt(ref flags, 31, this.bit31); CGeneric.SetBitInInt(ref flags, 32, this.bit32); Array.Copy(CGeneric.ConvertIntToByteArray(flags), 0, newHeaderData, 0, 4); Array.Copy(CGeneric.ConvertIntToByteArray(posX), 0, newHeaderData, 4, 4); Array.Copy(CGeneric.ConvertIntToByteArray(posY), 0, newHeaderData, 8, 4); //copy unknown data Array.Copy(rawData, 12, newHeaderData, 12, 16); newHeaderData[27] = this.textureIndex; if (transparencybit) { newHeaderData[31] = transparency; } return(newHeaderData); }
public byte[] GetRawData() { //init byte[] res = new byte[0]; //add the 4 unknown bytes... res = res.Concat(CGeneric.GiveMeArray(rawData, 0, 4)).ToArray(); //title scene length res = res.Concat(CGeneric.ConvertIntToByteArray(this.sceneName.Length)).ToArray(); //scene name res = res.Concat(sceneName).ToArray(); //size dynamicObject res = res.Concat(CGeneric.ConvertIntToByteArray(dynamicObjectList.Count)).ToArray(); //dynamic objectData foreach (CSBF1DynamicObject dynObj in dynamicObjectList) { res = res.Concat(dynObj.GetRawData()).ToArray(); } //size TextObject res = res.Concat(CGeneric.ConvertIntToByteArray(textObjectList.Count)).ToArray(); //TextObject foreach (CSBF1TextObject TexObj in textObjectList) { res = res.Concat(TexObj.GetRawData()).ToArray(); } //Size textureManagement res = res.Concat(CGeneric.ConvertIntToByteArray(textureManagementObjectList.Count)).ToArray(); //TextureManagement foreach (CSBF1TextureManagement texManObj in textureManagementObjectList) { res = res.Concat(texManObj.GetRawData()).ToArray(); } //dont renember why.. but needed byte[] test = new byte[] { 0x00, 0x00, 0x00, 0x00 }; res = res.Concat(test).ToArray(); return(res); }
private void MakeBFF2Chunks(Byte[] bffsData, int bffCount) { //store position and size of all BFF2 List <int> indexBFF2 = new List <int>(); List <int> sizeBFF2 = new List <int>(); int tmpPositionBFF2; //search all bff2 present in the 3FIB and grab index do { tmpPositionBFF2 = CGeneric.SearchBytesInArray(bffsData, CGeneric.patternBFF2, indexBFF2.Count()) - 12; if (tmpPositionBFF2 != -13) { //add index indexBFF2.Add(tmpPositionBFF2); //calculate size of previous BFF2 (if not the last) if (tmpPositionBFF2 != 0) { sizeBFF2.Add(indexBFF2[indexBFF2.Count() - 1] - indexBFF2[indexBFF2.Count() - 2]); } } else { //calculate size of last BFF2 try { sizeBFF2.Add(bffsData.Length - indexBFF2[indexBFF2.Count() - 1]); } catch { } //can occur only when modified rom doesn't have any BFF2 } } while (tmpPositionBFF2 != -13); //add bff2 list in the bff2Childs for (int i = 0; i < indexBFF2.Count(); i++) { Byte[] tmpByteBFF2 = new byte[sizeBFF2[i]]; Array.Copy(bffsData, indexBFF2[i], tmpByteBFF2, 0, sizeBFF2[i]); bff2Childs.Add(new CBFF2(tmpByteBFF2)); bff2Childs[bff2Childs.Count - 1].Init(); } }
private void ChunkDataToRessources(Byte[] ressourceData) { int generalIndex = 0; // check all the ressources list... for (int i = 0; i < ressourcesList.Count(); i++) { //grab only one item by one int sizeElement = CGeneric.ConvertByteArrayToInt(ressourcesList[i].ressourceSize); Byte[] tmpContainerData = new byte[sizeElement]; Array.Copy(ressourceData, generalIndex, tmpContainerData, 0, tmpContainerData.Length); //determine the type of data and fill in the apropriated list Byte[] dataPattern = new byte[4]; Array.Copy(tmpContainerData, 0, dataPattern, 0, dataPattern.Length); switch (CGeneric.ConvertByteArrayToInt(dataPattern)) { case (int)CGeneric.RessourceType.FIB: fibList.Add(new C3FIB(tmpContainerData, ressourcesList[i].ressourceName)); fibList[fibList.Count - 1].Init(); break; case (int)CGeneric.RessourceType.HVQM: hvqmList.Add(new CHVQM(tmpContainerData, ressourcesList[i].ressourceName)); break; case (int)CGeneric.RessourceType.SBF: sbfList.Add(new CSBF1(tmpContainerData, ressourcesList[i].ressourceName)); break; default: rdfList.Add(new CRDF(tmpContainerData, ressourcesList[i].ressourceName)); break; } generalIndex += sizeElement; if (sizeElement % 2 == 1) { generalIndex += 1; } } }
public int Get3FIBIndexWithFIBName(string name) { int increm = 0; var b = name.ToUpper().Replace("\0", ""); for (int z = 0; z < ressourcesList.Count(); z++) { var a = CGeneric.ConvertByteArrayToString(ressourcesList[z].ressourceName).ToUpper().Replace("\0", ""); if (a == b) { return(increm); } if (a.EndsWith(".BIF")) { increm++; } } return(-1); }
public void WriteAllData(FileStream fs) { fs.Position = indexRessourcesStart; // write the number of elements fs.Write(CGeneric.ConvertIntToByteArray(fibList.Count() + GetHVQMCount() + GetSBFCount() + GetRTFCount()), 0, 4); // index of data (for writing header) int indexData = (fibList.Count() + GetHVQMCount() + GetSBFCount() + GetRTFCount()) * 24 + 4; //write list header (FIB,HVQM,SBF1,RDF1) WriteListHeader(ref fs, ref indexData, fibList); WriteListHeader(ref fs, ref indexData, hvqmList); WriteListHeader(ref fs, ref indexData, sbfList); WriteListHeader(ref fs, ref indexData, rdfList); //write data associated WriteRessourceData(ref fs, fibList); WriteRessourceData(ref fs, hvqmList); WriteRessourceData(ref fs, sbfList); WriteRessourceData(ref fs, rdfList); }
private int ChunkTextureManagementObject(byte[] data, int nbTextureManagementObject, int indexDataStart) { byte[] lengthData = new byte[4]; int lengthDataInt; int totalSize = 0; for (int i = 0; i < nbTextureManagementObject; i++) { // get the length of the texture management object Array.Copy(data, indexDataStart, lengthData, 0, lengthData.Length); lengthDataInt = CSBF1TextureManagement.GetHeaderLength(CGeneric.ConvertByteArrayToInt(lengthData)); //create the new texture management item byte[] dataTextureManagementObject = new byte[lengthDataInt]; Array.Copy(data, indexDataStart, dataTextureManagementObject, 0, dataTextureManagementObject.Length); textureManagementObjectList.Add(new CSBF1TextureManagement(dataTextureManagementObject)); indexDataStart += lengthDataInt; totalSize += lengthDataInt; } return(totalSize); }
public override byte[] GetRawData() { //return rawData; byte[] res = new byte[12 + (bifList.Count * 0x10)]; Array.Copy(CGeneric.patternSBF1, 0, res, 0, CGeneric.patternSBF1.Length); Array.Copy(CGeneric.ConvertIntToByteArray(bifList.Count), 0, res, 4, 4); for (int i = 0; i < bifList.Count; i++) { Array.Copy(bifList[i], 0, res, 8 + i * bifList[0].Length, bifList[0].Length); } Array.Copy(CGeneric.ConvertIntToByteArray(scenesList.Count), 0, res, res.Length - 4, 4); //add each csbf1 scene foreach (CSBF1Scene scene in scenesList) { res = res.Concat(scene.GetRawData()).ToArray(); } this.rawData = res; return(res); }
public CSBF1Scene(byte[] rawData) { this.rawData = rawData; //read sceneNameLength byte[] sceneNameLength = new byte[4]; Array.Copy(rawData, 4, sceneNameLength, 0, sceneNameLength.Length); int sceneLength = CGeneric.ConvertByteArrayToInt(sceneNameLength); //extract sceneName this.sceneName = new byte[sceneLength]; Array.Copy(rawData, 8, sceneName, 0, sceneLength); //decompose scene in 3 parts. byte[] dataWithoutHeader = new Byte[rawData.Length - 8 - sceneLength]; Array.Copy(rawData, 8 + sceneLength, dataWithoutHeader, 0, dataWithoutHeader.Length); this.sceneNameDebug = CGeneric.ConvertByteArrayToString(sceneName); //decompose data of scene ChunkScene(dataWithoutHeader, 8 + sceneLength); //for text, decompose groups of text GroupTextData(); }
private void decomposeHeader() { //data grabbed from 4 first bytes (converted to bits) int dataInitial = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, 0, 4)); //set flags transparencybit = CGeneric.GetBitStateFromInt(dataInitial, 22); extra2 = CGeneric.GetBitStateFromInt(dataInitial, 26); //set unknown flags bit19 = CGeneric.GetBitStateFromInt(dataInitial, 19); bit20 = CGeneric.GetBitStateFromInt(dataInitial, 20); bit21 = CGeneric.GetBitStateFromInt(dataInitial, 21); bit23 = CGeneric.GetBitStateFromInt(dataInitial, 23); bit24 = CGeneric.GetBitStateFromInt(dataInitial, 24); bit25 = CGeneric.GetBitStateFromInt(dataInitial, 25); bit27 = CGeneric.GetBitStateFromInt(dataInitial, 27); bit28 = CGeneric.GetBitStateFromInt(dataInitial, 28); bit29 = CGeneric.GetBitStateFromInt(dataInitial, 29); bit30 = CGeneric.GetBitStateFromInt(dataInitial, 30); bit31 = CGeneric.GetBitStateFromInt(dataInitial, 31); bit32 = CGeneric.GetBitStateFromInt(dataInitial, 32); if (transparencybit) { this.transparency = rawData[31]; } if (rawData[3] != 8) { this.isCompressedTexture = true; } this.textureIndex = rawData[27]; this.posX = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, 4, 4)); this.posY = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(rawData, 8, 4)); }
private void ChunkScene(byte[] data, int headerSize) { //separate 3 types of data -> dynamicObject, text and textureManagment int generalIndex = 0; //get the number of dynamic object byte[] nbDynamicArray = new byte[4]; Array.Copy(data, generalIndex, nbDynamicArray, 0, nbDynamicArray.Length); //increment the global index with 4 (the size of nbDynamicArray.Length) generalIndex += nbDynamicArray.Length; //fill dynamic objects this.dynamicObjectList = new List <CSBF1DynamicObject>(); generalIndex += ChunkDynamicObject(data, CGeneric.ConvertByteArrayToInt(nbDynamicArray), generalIndex); //get the number of text object byte[] nbTextArray = new byte[4]; Array.Copy(data, generalIndex, nbTextArray, 0, nbTextArray.Length); //increment the global index with 4 (the size of nbDynamicArray.Length) generalIndex += nbTextArray.Length; //fill text objects this.textObjectList = new List <CSBF1TextObject>(); generalIndex += ChunkTextObject(data, CGeneric.ConvertByteArrayToInt(nbTextArray), generalIndex); //get the number of texture management object byte[] nbTextureArray = new byte[4]; Array.Copy(data, generalIndex, nbTextureArray, 0, nbTextureArray.Length); //increment the global index with 4 (the size of nbDynamicArray.Length) generalIndex += nbTextureArray.Length; //fill texture management object this.textureManagementObjectList = new List <CSBF1TextureManagement>(); generalIndex += ChunkTextureManagementObject(data, CGeneric.ConvertByteArrayToInt(nbTextureArray), generalIndex); //add 4 because 0x00000000 at the end of each scene.. //add specific value for ISO file (the 4th hidden thing in sbf... var hidden4thData = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(data, generalIndex, 4)); generalIndex += 4; if (hidden4thData != 0) { for (int i = 0; i < hidden4thData; i++) { var code4thData = CGeneric.ConvertByteArrayToInt(CGeneric.GiveMeArray(data, generalIndex, 4)); switch (code4thData) { case 0x1E: case 0x9E: generalIndex += 0x20; break; case 0x1F: generalIndex += 0x24; break; default: throw new NotImplementedException(); } } } var a = sceneNameDebug; //with the datasize determinated set the new rawData array byte[] newArrayRawData = new byte[generalIndex + headerSize]; Array.Copy(this.rawData, 0, newArrayRawData, 0, newArrayRawData.Length); this.rawData = newArrayRawData; }
//public void AddTexture(int indexScene, string bifName) //{ // //if the texture is already in the sbf, just add the texture to the scene // for(int i = 0; i < bifList.Count; i++) // { // if(bifName == CGeneric.ConvertByteArrayToString(bifList[i]).ToUpper()) // { // scenesList[indexScene].AddNewTextureObject(i); // return; // } // } // //else add before the texture and after add it to the scene // //store the name in lower just because it will be more pretty in the rom :) // bifList.Add(CGeneric.ConvertStringToByteArray(bifName.ToLower())); // scenesList[indexScene].AddNewTextureObject(bifList.Count - 1); //} public string GetBifName(int index) { return(CGeneric.ConvertByteArrayToString(bifList[index])); }
public void ReplaceTexture(int indexBif, string bifName) { bifList[indexBif] = CGeneric.ConvertStringToByteArray(bifName.ToLower()); }
public void SetSBF1(byte[] scene, int index) { var name = CGeneric.ConvertStringToByteArray(sbfList[index].GetRessourceName()); sbfList[index] = new CSBF1(scene, name); }
private void AddTexture(int location, int sizeX, int sizeY, int bpp, string text, int paletteLocation = 0, int paletteSize = 0) { graphicsRom.Add(new UncompressedRomTextureData(CGeneric.GiveMeArray(rawData, location, sizeX * sizeY * (bpp / 8)), location, sizeX, sizeY, bpp, text, CGeneric.GiveMeArray(rawData, paletteLocation, paletteSize), paletteLocation)); }
public static int GetHeaderLength(int headerValue) { var result = 28; if (CGeneric.GetBitStateFromInt(headerValue, 22)) { result += 4; } if (CGeneric.GetBitStateFromInt(headerValue, 26)) { result += 8; } return(result); //unknown data for now //switch (headerValue) //{ // case 0x00000000: return 0x1C; // case 0x00000002: return 0x1C; //tested // case 0x00000004: return 0x1C; //tested // case 0x00000006: return 0x1C; // case 0x00000008: return 0x1C; //tested // case 0x0000000C: return 0x1C; // case 0x00000040: return 0x24; //tested // case 0x00000044: return 0x24; //tested // case 0x00000080: return 0x1C; //tested // case 0x00000082: return 0x1C; // case 0x00000084: return 0x1C; //tested // case 0x00000200: return 0x1C; // case 0x00000400: return 0x20; //tested // case 0x00000402: return 0x20; // case 0x00000404: return 0x20; // case 0x00000406: return 0x20; //tested // case 0x00000482: return 0x20; // case 0x00002000: return 0x1C; // case 0x00002006: return 0x1C; //tested // case 0x00002040: return 0x24; // case 0x00002406: return 0x20; //tested // //test cas ISO only // case 0x00000664: return 0x28;//old vavlue 1C // case 0x00000764: return 0x28; // case 0x00000C02: return 0x20; // //case 0x000000D2: return 0x1C; //not exists // //case 0x000000D3: return 0x1C; //not exists // case 0x00000091: return 0x1C; // case 0x0000008C: return 0x1C; // case 0x00000010: return 0x1C; // case 0x00000210: return 0x1C; // case 0x00000204: return 0x1C; // case 0x00000104: return 0x1C; // case 0x00001000: return 0x1C; // case 0x00000001: return 0x1C;//tested // case 0x00000502: return 0x20; // case 0x00000202: return 0x1C; // //case 0x00000020: return 0x18;//not exist // default: throw new NotImplementedException(); //} }