mirror/AssetStudio
1
0
Fork 0
mirror of https://github.com/aelurum/AssetStudio.git synced 2025-07-18 03:24:15 -04:00
Code Issues Packages Projects Releases Wiki Activity

cleanup code

Browse Source
This commit is contained in:
Perfare
2017-04-10 03:13:08 +08:00
parent a928660dd3
commit d1ec1c29a4
13 changed files with 494 additions and 581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Unity Studio/Unity Studio Classes/AssetPreloadData.cs
View File

@ -138,10 +138,7 @@ namespace Unity_Studio
{
return member2;
}
else
{
member2.Add(member);
}
member2.Add(member);
}
return member2;
}

16
Unity Studio/Unity Studio Classes/BundleFile.cs
View File

@ -1,7 +1,7 @@
using System;
using System.Collections.Generic;
using System.Collections.Generic;
using System.IO;
using Lz4;
using SevenZip.Compression.LZMA;
namespace Unity_Studio
{
@ -97,7 +97,7 @@ namespace Unity_Studio
byte[] lzmaBuffer = new byte[lzmaSize];
b_Stream.Read(lzmaBuffer, 0, lzmaSize);
using (var lzmaStream = new EndianStream(SevenZip.Compression.LZMA.SevenZipHelper.StreamDecompress(new MemoryStream(lzmaBuffer)), EndianType.BigEndian))
using (var lzmaStream = new EndianStream(SevenZipHelper.StreamDecompress(new MemoryStream(lzmaBuffer)), EndianType.BigEndian))
{
getFiles(lzmaStream, 0);
}
@ -166,15 +166,14 @@ namespace Unity_Studio
EndianStream blocksInfo;
switch (flag & 0x3F)
{
default:
case 0://None
default://None
{
blocksInfo = new EndianStream(new MemoryStream(blocksInfoBytes), EndianType.BigEndian);
break;
}
case 1://LZMA
{
blocksInfo = new EndianStream(SevenZip.Compression.LZMA.SevenZipHelper.StreamDecompress(new MemoryStream(blocksInfoBytes)), EndianType.BigEndian);
blocksInfo = new EndianStream(SevenZipHelper.StreamDecompress(new MemoryStream(blocksInfoBytes)), EndianType.BigEndian);
break;
}
case 2://LZ4
@ -206,8 +205,7 @@ namespace Unity_Studio
var compressedBytes = b_Stream.ReadBytes(compressedSize);
switch (flag & 0x3F)
{
default:
case 0://None
default://None
{
assetsDataStream.Write(compressedBytes, 0, compressedSize);
break;
@ -217,7 +215,7 @@ namespace Unity_Studio
var uncompressedBytes = new byte[uncompressedSize];
using (var mstream = new MemoryStream(compressedBytes))
{
var decoder = SevenZip.Compression.LZMA.SevenZipHelper.StreamDecompress(mstream, uncompressedSize);
var decoder = SevenZipHelper.StreamDecompress(mstream, uncompressedSize);
decoder.Read(uncompressedBytes, 0, uncompressedSize);
decoder.Dispose();
}

46
Unity Studio/Unity Studio Classes/EndianStream.cs
View File

@ -20,115 +20,115 @@ namespace Unity_Studio
public EndianStream(Stream stream, EndianType endian) : base(stream) { }
public long Position { get { return base.BaseStream.Position; } set { base.BaseStream.Position = value; } }
public long Position { get { return BaseStream.Position; } set { BaseStream.Position = value; } }
public override short ReadInt16()
{
if (endian == EndianType.BigEndian)
{
a16 = base.ReadBytes(2);
a16 = ReadBytes(2);
Array.Reverse(a16);
return BitConverter.ToInt16(a16, 0);
}
else return base.ReadInt16();
return base.ReadInt16();
}
public override int ReadInt32()
{
if (endian == EndianType.BigEndian)
{
a32 = base.ReadBytes(4);
a32 = ReadBytes(4);
Array.Reverse(a32);
return BitConverter.ToInt32(a32, 0);
}
else return base.ReadInt32();
return base.ReadInt32();
}
public override long ReadInt64()
{
if (endian == EndianType.BigEndian)
{
a64 = base.ReadBytes(8);
a64 = ReadBytes(8);
Array.Reverse(a64);
return BitConverter.ToInt64(a64, 0);
}
else return base.ReadInt64();
return base.ReadInt64();
}
public override ushort ReadUInt16()
{
if (endian == EndianType.BigEndian)
{
a16 = base.ReadBytes(2);
a16 = ReadBytes(2);
Array.Reverse(a16);
return BitConverter.ToUInt16(a16, 0);
}
else return base.ReadUInt16();
return base.ReadUInt16();
}
public override uint ReadUInt32()
{
if (endian == EndianType.BigEndian)
{
a32 = base.ReadBytes(4);
a32 = ReadBytes(4);
Array.Reverse(a32);
return BitConverter.ToUInt32(a32, 0);
}
else return base.ReadUInt32();
return base.ReadUInt32();
}
public override ulong ReadUInt64()
{
if (endian == EndianType.BigEndian)
{
a64 = base.ReadBytes(8);
a64 = ReadBytes(8);
Array.Reverse(a64);
return BitConverter.ToUInt64(a64, 0);
}
else return base.ReadUInt64();
return base.ReadUInt64();
}
public override float ReadSingle()
{
if (endian == EndianType.BigEndian)
{
a32 = base.ReadBytes(4);
a32 = ReadBytes(4);
Array.Reverse(a32);
return BitConverter.ToSingle(a32, 0);
}
else return base.ReadSingle();
return base.ReadSingle();
}
public override double ReadDouble()
{
if (endian == EndianType.BigEndian)
{
a64 = base.ReadBytes(8);
a64 = ReadBytes(8);
Array.Reverse(a64);
return BitConverter.ToUInt64(a64, 0);
}
else return base.ReadDouble();
return base.ReadDouble();
}
public string ReadASCII(int length)
{
return Encoding.ASCII.GetString(base.ReadBytes(length));
return Encoding.ASCII.GetString(ReadBytes(length));
}
public void AlignStream(int alignment)
{
long pos = base.BaseStream.Position;
long pos = BaseStream.Position;
//long padding = alignment - pos + (pos / alignment) * alignment;
//if (padding != alignment) { base.BaseStream.Position += padding; }
if ((pos % alignment) != 0) { base.BaseStream.Position += alignment - (pos % alignment); }
if ((pos % alignment) != 0) { BaseStream.Position += alignment - (pos % alignment); }
}
public string ReadAlignedString(int length)
{
if (length > 0 && length < (base.BaseStream.Length - base.BaseStream.Position))//crude failsafe
if (length > 0 && length < (BaseStream.Length - BaseStream.Position))//crude failsafe
{
byte[] stringData = new byte[length];
base.Read(stringData, 0, length);
Read(stringData, 0, length);
var result = Encoding.UTF8.GetString(stringData); //must verify strange characters in PS3
/*string result = "";
@ -142,7 +142,7 @@ namespace Unity_Studio
AlignStream(4);
return result;
}
else { return ""; }
return "";
}
public string ReadStringToNull()

721
Unity Studio/Unity Studio Classes/Lz4DecoderStream.cs
View File

@ -7,538 +7,525 @@ using System.IO;
namespace Lz4
{
public class Lz4DecoderStream : Stream
{
public Lz4DecoderStream()
{
}
public class Lz4DecoderStream : Stream
{
public Lz4DecoderStream(Stream input, long inputLength = long.MaxValue)
{
Reset(input, inputLength);
}
public Lz4DecoderStream( Stream input, long inputLength = long.MaxValue )
{
Reset( input, inputLength );
}
public void Reset(Stream input, long inputLength = long.MaxValue)
{
this.inputLength = inputLength;
this.input = input;
public void Reset( Stream input, long inputLength = long.MaxValue )
{
this.inputLength = inputLength;
this.input = input;
phase = DecodePhase.ReadToken;
phase = DecodePhase.ReadToken;
decodeBufferPos = 0;
litLen = 0;
matLen = 0;
matDst = 0;
decodeBufferPos = 0;
inBufPos = DecBufLen;
inBufEnd = DecBufLen;
}
litLen = 0;
matLen = 0;
matDst = 0;
public override void Close()
{
this.input = null;
}
inBufPos = DecBufLen;
inBufEnd = DecBufLen;
}
private long inputLength;
private Stream input;
public override void Close()
{
input = null;
}
//because we might not be able to match back across invocations,
//we have to keep the last window's worth of bytes around for reuse
//we use a circular buffer for this - every time we write into this
//buffer, we also write the same into our output buffer
private long inputLength;
private Stream input;
private const int DecBufLen = 0x10000;
private const int DecBufMask = 0xFFFF;
//because we might not be able to match back across invocations,
//we have to keep the last window's worth of bytes around for reuse
//we use a circular buffer for this - every time we write into this
//buffer, we also write the same into our output buffer
private const int InBufLen = 128;
private const int DecBufLen = 0x10000;
private const int DecBufMask = 0xFFFF;
private byte[] decodeBuffer = new byte[DecBufLen + InBufLen];
private int decodeBufferPos, inBufPos, inBufEnd;
private const int InBufLen = 128;
//we keep track of which phase we're in so that we can jump right back
//into the correct part of decoding
private byte[] decodeBuffer = new byte[DecBufLen + InBufLen];
private int decodeBufferPos, inBufPos, inBufEnd;
private DecodePhase phase;
//we keep track of which phase we're in so that we can jump right back
//into the correct part of decoding
private enum DecodePhase
{
ReadToken,
ReadExLiteralLength,
CopyLiteral,
ReadOffset,
ReadExMatchLength,
CopyMatch,
}
private DecodePhase phase;
//state within interruptable phases and across phase boundaries is
//kept here - again, so that we can punt out and restart freely
private enum DecodePhase
{
ReadToken,
ReadExLiteralLength,
CopyLiteral,
ReadOffset,
ReadExMatchLength,
CopyMatch,
}
private int litLen, matLen, matDst;
//state within interruptable phases and across phase boundaries is
//kept here - again, so that we can punt out and restart freely
public override int Read( byte[] buffer, int offset, int count )
{
private int litLen, matLen, matDst;
public override int Read(byte[] buffer, int offset, int count)
{
#if CHECK_ARGS
if( buffer == null )
throw new ArgumentNullException( "buffer" );
if( offset < 0 || count < 0 || buffer.Length - count < offset )
throw new ArgumentOutOfRangeException();
if (buffer == null)
throw new ArgumentNullException("buffer");
if (offset < 0 || count < 0 || buffer.Length - count < offset)
throw new ArgumentOutOfRangeException();
if( input == null )
throw new InvalidOperationException();
if (input == null)
throw new InvalidOperationException();
#endif
int nRead, nToRead = count;
int nRead, nToRead = count;
var decBuf = decodeBuffer;
var decBuf = decodeBuffer;
//the stringy gotos are obnoxious, but their purpose is to
//make it *blindingly* obvious how the state machine transitions
//back and forth as it reads - remember, we can yield out of
//this routine in several places, and we must be able to re-enter
//and pick up where we left off!
//the stringy gotos are obnoxious, but their purpose is to
//make it *blindingly* obvious how the state machine transitions
//back and forth as it reads - remember, we can yield out of
//this routine in several places, and we must be able to re-enter
//and pick up where we left off!
#if LOCAL_SHADOW
var phase = this.phase;
var inBufPos = this.inBufPos;
var inBufEnd = this.inBufEnd;
#endif
switch( phase )
{
case DecodePhase.ReadToken:
goto readToken;
switch (phase)
{
case DecodePhase.ReadToken:
goto readToken;
case DecodePhase.ReadExLiteralLength:
goto readExLiteralLength;
case DecodePhase.ReadExLiteralLength:
goto readExLiteralLength;
case DecodePhase.CopyLiteral:
goto copyLiteral;
case DecodePhase.CopyLiteral:
goto copyLiteral;
case DecodePhase.ReadOffset:
goto readOffset;
case DecodePhase.ReadOffset:
goto readOffset;
case DecodePhase.ReadExMatchLength:
goto readExMatchLength;
case DecodePhase.ReadExMatchLength:
goto readExMatchLength;
case DecodePhase.CopyMatch:
goto copyMatch;
}
case DecodePhase.CopyMatch:
goto copyMatch;
}
readToken:
int tok;
if( inBufPos < inBufEnd )
{
tok = decBuf[inBufPos++];
}
else
{
readToken:
int tok;
if (inBufPos < inBufEnd)
{
tok = decBuf[inBufPos++];
}
else
{
#if LOCAL_SHADOW
this.inBufPos = inBufPos;
#endif
tok = ReadByteCore();
tok = ReadByteCore();
#if LOCAL_SHADOW
inBufPos = this.inBufPos;
inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
if( tok == -1 )
goto finish;
if (tok == -1)
goto finish;
#endif
}
}
litLen = tok >> 4;
matLen = (tok & 0xF) + 4;
litLen = tok >> 4;
matLen = (tok & 0xF) + 4;
switch( litLen )
{
case 0:
phase = DecodePhase.ReadOffset;
goto readOffset;
switch (litLen)
{
case 0:
phase = DecodePhase.ReadOffset;
goto readOffset;
case 0xF:
phase = DecodePhase.ReadExLiteralLength;
goto readExLiteralLength;
case 0xF:
phase = DecodePhase.ReadExLiteralLength;
goto readExLiteralLength;
default:
phase = DecodePhase.CopyLiteral;
goto copyLiteral;
}
default:
phase = DecodePhase.CopyLiteral;
goto copyLiteral;
}
readExLiteralLength:
int exLitLen;
if( inBufPos < inBufEnd )
{
exLitLen = decBuf[inBufPos++];
}
else
{
readExLiteralLength:
int exLitLen;
if (inBufPos < inBufEnd)
{
exLitLen = decBuf[inBufPos++];
}
else
{
#if LOCAL_SHADOW
this.inBufPos = inBufPos;
#endif
exLitLen = ReadByteCore();
#if LOCAL_SHADOW
exLitLen = ReadByteCore();
#if LOCAL_SHADOW
inBufPos = this.inBufPos;
inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
if( exLitLen == -1 )
goto finish;
if (exLitLen == -1)
goto finish;
#endif
}
}
litLen += exLitLen;
if( exLitLen == 255 )
goto readExLiteralLength;
litLen += exLitLen;
if (exLitLen == 255)
goto readExLiteralLength;
phase = DecodePhase.CopyLiteral;
goto copyLiteral;
phase = DecodePhase.CopyLiteral;
goto copyLiteral;
copyLiteral:
int nReadLit = litLen < nToRead ? litLen : nToRead;
if( nReadLit != 0 )
{
if( inBufPos + nReadLit <= inBufEnd )
{
int ofs = offset;
copyLiteral:
int nReadLit = litLen < nToRead ? litLen : nToRead;
if (nReadLit != 0)
{
if (inBufPos + nReadLit <= inBufEnd)
{
int ofs = offset;
for( int c = nReadLit; c-- != 0; )
buffer[ofs++] = decBuf[inBufPos++];
for (int c = nReadLit; c-- != 0;)
buffer[ofs++] = decBuf[inBufPos++];
nRead = nReadLit;
}
else
{
nRead = nReadLit;
}
else
{
#if LOCAL_SHADOW
this.inBufPos = inBufPos;
#endif
nRead = ReadCore( buffer, offset, nReadLit );
nRead = ReadCore(buffer, offset, nReadLit);
#if LOCAL_SHADOW
inBufPos = this.inBufPos;
inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
if( nRead == 0 )
goto finish;
if (nRead == 0)
goto finish;
#endif
}
}
offset += nRead;
nToRead -= nRead;
offset += nRead;
nToRead -= nRead;
litLen -= nRead;
litLen -= nRead;
if( litLen != 0 )
goto copyLiteral;
}
if (litLen != 0)
goto copyLiteral;
}
if( nToRead == 0 )
goto finish;
if (nToRead == 0)
goto finish;
phase = DecodePhase.ReadOffset;
goto readOffset;
phase = DecodePhase.ReadOffset;
goto readOffset;
readOffset:
if( inBufPos + 1 < inBufEnd )
{
matDst = (decBuf[inBufPos + 1] << 8) | decBuf[inBufPos];
inBufPos += 2;
}
else
{
readOffset:
if (inBufPos + 1 < inBufEnd)
{
matDst = (decBuf[inBufPos + 1] << 8) | decBuf[inBufPos];
inBufPos += 2;
}
else
{
#if LOCAL_SHADOW
this.inBufPos = inBufPos;
#endif
matDst = ReadOffsetCore();
matDst = ReadOffsetCore();
#if LOCAL_SHADOW
inBufPos = this.inBufPos;
inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
if( matDst == -1 )
goto finish;
if (matDst == -1)
goto finish;
#endif
}
}
if( matLen == 15 + 4 )
{
phase = DecodePhase.ReadExMatchLength;
goto readExMatchLength;
}
else
{
phase = DecodePhase.CopyMatch;
goto copyMatch;
}
if (matLen == 15 + 4)
{
phase = DecodePhase.ReadExMatchLength;
goto readExMatchLength;
}
else
{
phase = DecodePhase.CopyMatch;
goto copyMatch;
}
readExMatchLength:
int exMatLen;
if( inBufPos < inBufEnd )
{
exMatLen = decBuf[inBufPos++];
}
else
{
readExMatchLength:
int exMatLen;
if (inBufPos < inBufEnd)
{
exMatLen = decBuf[inBufPos++];
}
else
{
#if LOCAL_SHADOW
this.inBufPos = inBufPos;
#endif
exMatLen = ReadByteCore();
exMatLen = ReadByteCore();
#if LOCAL_SHADOW
inBufPos = this.inBufPos;
inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
if( exMatLen == -1 )
goto finish;
if (exMatLen == -1)
goto finish;
#endif
}
}
matLen += exMatLen;
if( exMatLen == 255 )
goto readExMatchLength;
matLen += exMatLen;
if (exMatLen == 255)
goto readExMatchLength;
phase = DecodePhase.CopyMatch;
goto copyMatch;
phase = DecodePhase.CopyMatch;
goto copyMatch;
copyMatch:
int nCpyMat = matLen < nToRead ? matLen : nToRead;
if( nCpyMat != 0 )
{
nRead = count - nToRead;
copyMatch:
int nCpyMat = matLen < nToRead ? matLen : nToRead;
if (nCpyMat != 0)
{
nRead = count - nToRead;
int bufDst = matDst - nRead;
if( bufDst > 0 )
{
//offset is fairly far back, we need to pull from the buffer
int bufDst = matDst - nRead;
if (bufDst > 0)
{
//offset is fairly far back, we need to pull from the buffer
int bufSrc = decodeBufferPos - bufDst;
if( bufSrc < 0 )
bufSrc += DecBufLen;
int bufCnt = bufDst < nCpyMat ? bufDst : nCpyMat;
int bufSrc = decodeBufferPos - bufDst;
if (bufSrc < 0)
bufSrc += DecBufLen;
int bufCnt = bufDst < nCpyMat ? bufDst : nCpyMat;
for( int c = bufCnt; c-- != 0; )
buffer[offset++] = decBuf[bufSrc++ & DecBufMask];
}
else
{
bufDst = 0;
}
for (int c = bufCnt; c-- != 0;)
buffer[offset++] = decBuf[bufSrc++ & DecBufMask];
}
else
{
bufDst = 0;
}
int sOfs = offset - matDst;
for( int i = bufDst; i < nCpyMat; i++ )
buffer[offset++] = buffer[sOfs++];
int sOfs = offset - matDst;
for (int i = bufDst; i < nCpyMat; i++)
buffer[offset++] = buffer[sOfs++];
nToRead -= nCpyMat;
matLen -= nCpyMat;
}
nToRead -= nCpyMat;
matLen -= nCpyMat;
}
if( nToRead == 0 )
goto finish;
if (nToRead == 0)
goto finish;
phase = DecodePhase.ReadToken;
goto readToken;
phase = DecodePhase.ReadToken;
goto readToken;
finish:
nRead = count - nToRead;
finish:
nRead = count - nToRead;
int nToBuf = nRead < DecBufLen ? nRead : DecBufLen;
int repPos = offset - nToBuf;
int nToBuf = nRead < DecBufLen ? nRead : DecBufLen;
int repPos = offset - nToBuf;
if( nToBuf == DecBufLen )
{
Buffer.BlockCopy( buffer, repPos, decBuf, 0, DecBufLen );
decodeBufferPos = 0;
}
else
{
int decPos = decodeBufferPos;
if (nToBuf == DecBufLen)
{
Buffer.BlockCopy(buffer, repPos, decBuf, 0, DecBufLen);
decodeBufferPos = 0;
}
else
{
int decPos = decodeBufferPos;
while( nToBuf-- != 0 )
decBuf[decPos++ & DecBufMask] = buffer[repPos++];
while (nToBuf-- != 0)
decBuf[decPos++ & DecBufMask] = buffer[repPos++];
decodeBufferPos = decPos & DecBufMask;
}
decodeBufferPos = decPos & DecBufMask;
}
#if LOCAL_SHADOW
this.phase = phase;
this.inBufPos = inBufPos;
#endif
return nRead;
}
return nRead;
}
private int ReadByteCore()
{
var buf = decodeBuffer;
private int ReadByteCore()
{
var buf = decodeBuffer;
if( inBufPos == inBufEnd )
{
int nRead = input.Read( buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength );
if (inBufPos == inBufEnd)
{
int nRead = input.Read(buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength);
#if CHECK_EOF
if( nRead == 0 )
return -1;
if (nRead == 0)
return -1;
#endif
inputLength -= nRead;
inputLength -= nRead;
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
}
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
}
return buf[inBufPos++];
}
return buf[inBufPos++];
}
private int ReadOffsetCore()
{
var buf = decodeBuffer;
private int ReadOffsetCore()
{
var buf = decodeBuffer;
if( inBufPos == inBufEnd )
{
int nRead = input.Read( buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength );
if (inBufPos == inBufEnd)
{
int nRead = input.Read(buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength);
#if CHECK_EOF
if( nRead == 0 )
return -1;
if (nRead == 0)
return -1;
#endif
inputLength -= nRead;
inputLength -= nRead;
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
}
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
}
if( inBufEnd - inBufPos == 1 )
{
buf[DecBufLen] = buf[inBufPos];
if (inBufEnd - inBufPos == 1)
{
buf[DecBufLen] = buf[inBufPos];
int nRead = input.Read( buf, DecBufLen + 1,
InBufLen - 1 < inputLength ? InBufLen - 1 : (int)inputLength );
int nRead = input.Read(buf, DecBufLen + 1,
InBufLen - 1 < inputLength ? InBufLen - 1 : (int)inputLength);
#if CHECK_EOF
if( nRead == 0 )
{
inBufPos = DecBufLen;
inBufEnd = DecBufLen + 1;
if (nRead == 0)
{
inBufPos = DecBufLen;
inBufEnd = DecBufLen + 1;
return -1;
}
return -1;
}
#endif
inputLength -= nRead;
inputLength -= nRead;
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead + 1;
}
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead + 1;
}
int ret = (buf[inBufPos + 1] << 8) | buf[inBufPos];
inBufPos += 2;
int ret = (buf[inBufPos + 1] << 8) | buf[inBufPos];
inBufPos += 2;
return ret;
}
return ret;
}
private int ReadCore( byte[] buffer, int offset, int count )
{
int nToRead = count;
private int ReadCore(byte[] buffer, int offset, int count)
{
int nToRead = count;
var buf = decodeBuffer;
int inBufLen = inBufEnd - inBufPos;
var buf = decodeBuffer;
int inBufLen = inBufEnd - inBufPos;
int fromBuf = nToRead < inBufLen ? nToRead : inBufLen;
if( fromBuf != 0 )
{
var bufPos = inBufPos;
int fromBuf = nToRead < inBufLen ? nToRead : inBufLen;
if (fromBuf != 0)
{
var bufPos = inBufPos;
for( int c = fromBuf; c-- != 0; )
buffer[offset++] = buf[bufPos++];
for (int c = fromBuf; c-- != 0;)
buffer[offset++] = buf[bufPos++];
inBufPos = bufPos;
nToRead -= fromBuf;
}
inBufPos = bufPos;
nToRead -= fromBuf;
}
if( nToRead != 0 )
{
int nRead;
if (nToRead != 0)
{
int nRead;
if( nToRead >= InBufLen )
{
nRead = input.Read( buffer, offset,
nToRead < inputLength ? nToRead : (int)inputLength );
nToRead -= nRead;
}
else
{
nRead = input.Read( buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength );
if (nToRead >= InBufLen)
{
nRead = input.Read(buffer, offset,
nToRead < inputLength ? nToRead : (int)inputLength);
nToRead -= nRead;
}
else
{
nRead = input.Read(buf, DecBufLen,
InBufLen < inputLength ? InBufLen : (int)inputLength);
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
inBufPos = DecBufLen;
inBufEnd = DecBufLen + nRead;
fromBuf = nToRead < nRead ? nToRead : nRead;
fromBuf = nToRead < nRead ? nToRead : nRead;
var bufPos = inBufPos;
var bufPos = inBufPos;
for( int c = fromBuf; c-- != 0; )
buffer[offset++] = buf[bufPos++];
for (int c = fromBuf; c-- != 0;)
buffer[offset++] = buf[bufPos++];
inBufPos = bufPos;
nToRead -= fromBuf;
}
inBufPos = bufPos;
nToRead -= fromBuf;
}
inputLength -= nRead;
}
inputLength -= nRead;
}
return count - nToRead;
}
return count - nToRead;
}
#region Stream internals
#region Stream internals
public override bool CanRead
{
get { return true; }
}
public override bool CanRead => true;
public override bool CanSeek
{
get { return false; }
}
public override bool CanSeek => false;
public override bool CanWrite
{
get { return false; }
}
public override bool CanWrite => false;
public override void Flush()
{
}
public override void Flush()
{
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Length
{
get { throw new NotSupportedException(); }
}
public override long Position
{
get { throw new NotSupportedException(); }
set { throw new NotSupportedException(); }
}
public override long Position
{
get { throw new NotSupportedException(); }
set { throw new NotSupportedException(); }
}
public override long Seek( long offset, SeekOrigin origin )
{
throw new NotSupportedException();
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength( long value )
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
public override void Write( byte[] buffer, int offset, int count )
{
throw new NotSupportedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
throw new NotSupportedException();
}
#endregion
}
#endregion
}
}

37
Unity Studio/Unity Studio Classes/UnityStudio.cs
View File

@ -1105,10 +1105,6 @@ namespace Unity_Studio
}
}
}
else
{
//bool stop = true;
}
}
MeshPD.uniqueID = keepID;
@ -1653,7 +1649,8 @@ namespace Unity_Studio
public static bool ExportAudioClip(AssetPreloadData asset, string exportFilename, string exportFileextension)
{
var oldextension = exportFileextension;
if ((bool)Properties.Settings.Default["convertfsb"] && exportFileextension == ".fsb")
var convertfsb = (bool)Properties.Settings.Default["convertfsb"];
if (convertfsb && exportFileextension == ".fsb")
{
exportFileextension = ".wav";
}
@ -1661,7 +1658,7 @@ namespace Unity_Studio
if (ExportFileExists(exportFullname))
return false;
var m_AudioClip = new AudioClip(asset, true);
if ((bool)Properties.Settings.Default["convertfsb"] && oldextension == ".fsb")
if (convertfsb && oldextension == ".fsb")
{
FMOD.System system;
FMOD.Sound sound;
@ -1769,10 +1766,10 @@ namespace Unity_Studio
{
count = 4;
}
var vertices = new ManagedFbx.Vector3[m_Mesh.m_VertexCount];
var vertices = new Vector3[m_Mesh.m_VertexCount];
for (int v = 0; v < m_Mesh.m_VertexCount; v++)
{
vertices[v] = new ManagedFbx.Vector3(
vertices[v] = new Vector3(
m_Mesh.m_Vertices[v * count],
m_Mesh.m_Vertices[v * count + 1],
m_Mesh.m_Vertices[v * count + 2]);
@ -1801,10 +1798,10 @@ namespace Unity_Studio
count = 4;
}
var normals = new ManagedFbx.Vector3[m_Mesh.m_VertexCount];
var normals = new Vector3[m_Mesh.m_VertexCount];
for (int n = 0; n < m_Mesh.m_VertexCount; n++)
{
normals[n] = new ManagedFbx.Vector3(
normals[n] = new Vector3(
m_Mesh.m_Normals[n * count],
m_Mesh.m_Normals[n * count + 1],
m_Mesh.m_Normals[n * count + 2]);
@ -1815,20 +1812,20 @@ namespace Unity_Studio
#region Colors
if (m_Mesh.m_Colors == null)
{
var colors = new ManagedFbx.Colour[m_Mesh.m_VertexCount];
var colors = new Colour[m_Mesh.m_VertexCount];
for (int c = 0; c < m_Mesh.m_VertexCount; c++)
{
colors[c] = new ManagedFbx.Colour(
colors[c] = new Colour(
0.5f, 0.5f, 0.5f, 1.0f);
}
mesh.VertexColours = colors;
}
else if (m_Mesh.m_Colors.Length == m_Mesh.m_VertexCount * 3)
{
var colors = new ManagedFbx.Colour[m_Mesh.m_VertexCount];
var colors = new Colour[m_Mesh.m_VertexCount];
for (int c = 0; c < m_Mesh.m_VertexCount; c++)
{
colors[c] = new ManagedFbx.Colour(
colors[c] = new Colour(
m_Mesh.m_Colors[c * 4],
m_Mesh.m_Colors[c * 4 + 1],
m_Mesh.m_Colors[c * 4 + 2],
@ -1838,10 +1835,10 @@ namespace Unity_Studio
}
else
{
var colors = new ManagedFbx.Colour[m_Mesh.m_VertexCount];
var colors = new Colour[m_Mesh.m_VertexCount];
for (int c = 0; c < m_Mesh.m_VertexCount; c++)
{
colors[c] = new ManagedFbx.Colour(
colors[c] = new Colour(
m_Mesh.m_Colors[c * 4],
m_Mesh.m_Colors[c * 4 + 1],
m_Mesh.m_Colors[c * 4 + 2],
@ -1853,19 +1850,19 @@ namespace Unity_Studio
#region UV
if (m_Mesh.m_UV1 != null && m_Mesh.m_UV1.Length == m_Mesh.m_VertexCount * 2)
{
var uv = new ManagedFbx.Vector2[m_Mesh.m_VertexCount];
var uv = new Vector2[m_Mesh.m_VertexCount];
for (int c = 0; c < m_Mesh.m_VertexCount; c++)
{
uv[c] = new ManagedFbx.Vector2(m_Mesh.m_UV1[c * 2], m_Mesh.m_UV1[c * 2 + 1]);
uv[c] = new Vector2(m_Mesh.m_UV1[c * 2], m_Mesh.m_UV1[c * 2 + 1]);
}
mesh.TextureCoords = uv;
}
else if (m_Mesh.m_UV2 != null && m_Mesh.m_UV2.Length == m_Mesh.m_VertexCount * 2)
{
var uv = new ManagedFbx.Vector2[m_Mesh.m_VertexCount];
var uv = new Vector2[m_Mesh.m_VertexCount];
for (int c = 0; c < m_Mesh.m_VertexCount; c++)
{
uv[c] = new ManagedFbx.Vector2(m_Mesh.m_UV2[c * 2], m_Mesh.m_UV2[c * 2 + 1]);
uv[c] = new Vector2(m_Mesh.m_UV2[c * 2], m_Mesh.m_UV2[c * 2 + 1]);
}
mesh.TextureCoords = uv;
}