public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
GameObject parentObj = gameObj as GameObject;
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasChildren = reader.ReadBoolean(); // _children
if (hasChildren)
{
uint numChildren = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numChildren; ++i)
{
GameObject children = new GameObject("Child_" + i.ToString());
if (parentObj && LoadObject(children, reader, owner))
{
children.transform.SetParent(parentObj.transform, false);
}
}
}
return(true);
}
void readMaterialProperty(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
bool frontAndBack = reader.ReadBoolean();
Vector4 frontProp = new Vector4(
reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Vector4 backProp = new Vector4(
reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasInitBound = reader.ReadBoolean(); // _initialBound
if (hasInitBound)
{
long blockSize = ReadBracket(reader, owner);
Vector3 boudCenter = new Vector3(
(float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble());
double radius = reader.ReadDouble();
}
bool hasComputeBoundCB = reader.ReadBoolean(); // _computeBoundCallback
if (hasComputeBoundCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasUpdateCB = reader.ReadBoolean(); // _updateCallback
if (hasUpdateCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasEventCB = reader.ReadBoolean(); // _eventCallback
if (hasEventCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasCullCB = reader.ReadBoolean(); // _cullCallback
if (hasCullCB)
{
LoadObject(gameObj, reader, owner);
}
bool cullingActive = reader.ReadBoolean(); // _cullingActive
int nodeMask = reader.ReadInt32(); // _nodeMask
bool hasStateSet = reader.ReadBoolean(); // _stateset
if (hasStateSet)
{
LoadObject(gameObj, reader, owner);
}
return(true);
}
void readArrayListData(string name, Mesh mesh, BinaryReader reader, ReaderOSGB owner)
{
uint numArrayData = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numArrayData; ++i)
{
blockSize = ReadBracket(reader, owner);
readArrayData(name + i.ToString(), mesh, reader, owner);
}
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
GameObject parentObj = gameObj as GameObject;
if (!base.read(gameObj, reader, owner))
{
return(false);
}
PagedData pagedData = parentObj.AddComponent <PagedData>();
pagedData._mainReader = owner;
int centerMode = reader.ReadInt32(); // _centerMode
bool hasUserCenter = reader.ReadBoolean(); // _userDefinedCenter, _radius
if (hasUserCenter)
{
double centerX = reader.ReadDouble();
double centerY = reader.ReadDouble();
double centerZ = reader.ReadDouble();
double radius = reader.ReadDouble();
pagedData._bounds = new BoundingSphere(
new Vector3((float)centerX, (float)centerY, (float)centerZ), (float)radius);
}
// TODO: _bounds in default center mode?
int rangeMode = reader.ReadInt32(); // _rangeMode
pagedData._rangeMode = (rangeMode > 0)
? PagedData.RangeMode.PixelSize : PagedData.RangeMode.Distance;
bool hasRanges = reader.ReadBoolean(); // _rangeList
if (hasRanges)
{
uint numRanges = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numRanges; ++i)
{
float minR = reader.ReadSingle();
float maxR = reader.ReadSingle();
pagedData._ranges.Add(new Vector2(minR, maxR));
}
}
return(true);
}
void readArrayData(string name, Mesh mesh, BinaryReader reader, ReaderOSGB owner)
{
long blockSize = ReadBracket(reader, owner);
bool hasArray = reader.ReadBoolean();
if (hasArray)
{
int numComponents = 0, dataSize = 0, arraySize = 0;
byte[] data = readArray(reader, owner, ref numComponents, ref dataSize, ref arraySize);
if (name == "vertex")
{
Vector3[] vertices = new Vector3[arraySize];
GCHandle handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
Marshal.Copy(data, 0, handle.AddrOfPinnedObject(), data.Length);
mesh.vertices = vertices;
}
else if (name == "normal")
{
Vector3[] normals = new Vector3[arraySize];
GCHandle handle = GCHandle.Alloc(normals, GCHandleType.Pinned);
Marshal.Copy(data, 0, handle.AddrOfPinnedObject(), data.Length);
mesh.normals = normals;
}
else if (name == "texCoord0")
{
Vector2[] texcoords = new Vector2[arraySize];
GCHandle handle = GCHandle.Alloc(texcoords, GCHandleType.Pinned);
Marshal.Copy(data, 0, handle.AddrOfPinnedObject(), data.Length);
mesh.uv = texcoords;
}
else // TODO: other types
{
Debug.LogWarning("Not implemented: " + name + ", " + arraySize +
"; components = " + numComponents + "; dataSize = " + dataSize);
}
}
bool hasIndices = reader.ReadBoolean();
if (hasIndices)
{
int numComponents = 0, dataSize = 0, arraySize = 0;
byte[] data = readArray(reader, owner, ref numComponents, ref dataSize, ref arraySize);
}
int binding = reader.ReadInt32();
int normalizeValue = reader.ReadInt32();
}
public static long ReadBracket(BinaryReader reader, ReaderOSGB owner)
{
if (owner._useBrackets)
{
if (owner._version > 148)
{
return(reader.ReadInt64());
}
else
{
return(reader.ReadInt32());
}
}
return(-1);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
int colorMode = reader.ReadInt32(); // _colorMode
bool hasMtlProp = reader.ReadBoolean(); // _ambient
if (hasMtlProp)
{
readMaterialProperty(gameObj, reader, owner);
}
hasMtlProp = reader.ReadBoolean(); // _diffuse
if (hasMtlProp)
{
readMaterialProperty(gameObj, reader, owner);
}
hasMtlProp = reader.ReadBoolean(); // _specular
if (hasMtlProp)
{
readMaterialProperty(gameObj, reader, owner);
}
hasMtlProp = reader.ReadBoolean(); // _emission
if (hasMtlProp)
{
readMaterialProperty(gameObj, reader, owner);
}
hasMtlProp = reader.ReadBoolean(); // _shininess
if (hasMtlProp)
{
bool frontAndBack = reader.ReadBoolean();
float frontValue = reader.ReadSingle();
float backValue = reader.ReadSingle();
}
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
string name = ReadString(reader); // _name
int dataVariance = reader.ReadInt32(); // _dataVariance
bool hasUserData = reader.ReadBoolean(); // _userData
if (hasUserData)
{
Debug.LogWarning("_userData not implemented");
return(false);
}
if (name.Length > 0)
{
gameObj.name = name;
}
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasImage = reader.ReadBoolean(); // _image
if (hasImage)
{
owner._preloadedTexture = LoadImage(gameObj, reader, owner);
}
int texWidth = reader.ReadInt32();
int texHeight = reader.ReadInt32();
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasUpdateCB = reader.ReadBoolean(); // _updateCallback
if (hasUpdateCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasEventCB = reader.ReadBoolean(); // _eventCallback
if (hasEventCB)
{
LoadObject(gameObj, reader, owner);
}
return(true);
}
void readModes(Object gameObj, BinaryReader reader, ReaderOSGB owner, bool asTexMode)
{
int numTexUnits = asTexMode ? reader.ReadInt32() : 1;
if (asTexMode)
{
ReadBracket(reader, owner);
}
for (int u = 0; u < numTexUnits; ++u)
{
int numModes = reader.ReadInt32();
if (numModes > 0)
{
long blockSize = ReadBracket(reader, owner);
for (int i = 0; i < numModes; ++i)
{
int glEnum = reader.ReadInt32();
int value = reader.ReadInt32();
}
}
}
}
void readAttributes(Object gameObj, BinaryReader reader, ReaderOSGB owner, bool asTexAttr)
{
int numTexUnits = asTexAttr ? reader.ReadInt32() : 1;
if (asTexAttr)
{
long blockSize = ReadBracket(reader, owner);
}
for (int u = 0; u < numTexUnits; ++u)
{
int numAttrs = reader.ReadInt32();
if (numAttrs > 0)
{
long blockSize = ReadBracket(reader, owner);
for (int i = 0; i < numAttrs; ++i)
{
LoadObject(gameObj, reader, owner);
int value = reader.ReadInt32();
}
}
}
}
public static bool LoadObject(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
string className = ReadString(reader);
long blockSize = ReadBracket(reader, owner);
uint id = reader.ReadUInt32();
className = className.Replace("::", "_");
if (owner._sharedObjects.ContainsKey(id))
{
//Debug.Log("Shared object " + className + "-" + id);
return(true); // TODO: how to share nodes?
}
else
{
owner._sharedObjects[id] = gameObj;
}
System.Type classType = System.Type.GetType(className);
if (classType == null)
{
Debug.LogWarning("Object type " + className + " not implemented");
return(false);
}
ObjectBase classObj = System.Activator.CreateInstance(classType) as ObjectBase;
if (classObj == null)
{
Debug.LogWarning("Object instance " + className + " failed to create");
return(false);
}
else
{
return(classObj.read(gameObj, reader, owner));
}
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasStateSet = reader.ReadBoolean(); // _stateset
if (hasStateSet)
{
LoadObject(gameObj, reader, owner);
}
bool hasInitBound = reader.ReadBoolean(); // _initialBound
if (hasInitBound)
{
long blockSize = ReadBracket(reader, owner);
Vector3 boundMin = new Vector3(
(float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble());
Vector3 boundMax = new Vector3(
(float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble());
}
bool hasComputeBoundCB = reader.ReadBoolean(); // _computeBoundCallback
if (hasComputeBoundCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasShape = reader.ReadBoolean(); // _shape
if (hasShape)
{
LoadObject(gameObj, reader, owner);
}
bool enableDisplaylists = reader.ReadBoolean(); // _supportsDisplayList
bool useDisplaylists = reader.ReadBoolean(); // _useDisplayList
bool useVBO = reader.ReadBoolean(); // _useVertexBufferObjects
bool hasUpdateCB = reader.ReadBoolean(); // _updateCallback
if (hasUpdateCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasEventCB = reader.ReadBoolean(); // _eventCallback
if (hasEventCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasCullCB = reader.ReadBoolean(); // _cullCallback
if (hasCullCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasDrawCB = reader.ReadBoolean(); // _drawCallback
if (hasDrawCB)
{
LoadObject(gameObj, reader, owner);
}
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasModes = reader.ReadBoolean(); // _modeList
if (hasModes)
{
readModes(gameObj, reader, owner, false);
}
bool hasAttrs = reader.ReadBoolean(); // _attributeList
if (hasAttrs)
{
readAttributes(gameObj, reader, owner, false);
}
hasModes = reader.ReadBoolean(); // _textureModeList
if (hasModes)
{
readModes(gameObj, reader, owner, true);
}
hasAttrs = reader.ReadBoolean(); // _textureAttributeList
if (hasAttrs)
{
readAttributes(gameObj, reader, owner, true);
}
bool hasUniforms = reader.ReadBoolean(); // _uniformList
if (hasUniforms)
{
int numUniforms = reader.ReadInt32();
long blockSize = ReadBracket(reader, owner);
for (int i = 0; i < numUniforms; ++i)
{
LoadObject(gameObj, reader, owner);
int value = reader.ReadInt32();
}
}
int renderingHint = reader.ReadInt32(); // _renderingHint
int binMode = reader.ReadInt32(); // _binMode
int binNumber = reader.ReadInt32(); // _binNum
string binName = ReadString(reader); // _binName
bool nestedBin = reader.ReadBoolean(); // _nestRenderBins
bool hasUpdateCB = reader.ReadBoolean(); // _updateCallback
if (hasUpdateCB)
{
LoadObject(gameObj, reader, owner);
}
bool hasEventCB = reader.ReadBoolean(); // _eventCallback
if (hasEventCB)
{
LoadObject(gameObj, reader, owner);
}
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
GameObject parentObj = gameObj as GameObject;
if (!base.read(gameObj, reader, owner))
{
return(false);
}
Mesh mesh = new Mesh();
mesh.name = parentObj.name + "_Mesh";
uint numPrimitives = reader.ReadUInt32(); // _primitives
for (uint i = 0; i < numPrimitives; ++i)
{
if (owner._version < 112)
{
readPrimitive(mesh, reader, owner);
}
else
{
} // TODO
}
if (owner._version < 112)
{
bool hasArrayData = reader.ReadBoolean(); // _vertexData
if (hasArrayData)
{
readArrayData("vertex", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _normalData
if (hasArrayData)
{
readArrayData("normal", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _colorData
if (hasArrayData)
{
readArrayData("color", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _secondaryColorData
if (hasArrayData)
{
readArrayData("secondaryColor", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _fogCoordData
if (hasArrayData)
{
readArrayData("fogCoord", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _texCoordList
if (hasArrayData)
{
readArrayListData("texCoord", mesh, reader, owner);
}
hasArrayData = reader.ReadBoolean(); // _vertexAttribList
if (hasArrayData)
{
readArrayListData("vertexAttrib", mesh, reader, owner);
}
}
else
{
LoadObject(mesh, reader, owner); // _vertexData
LoadObject(mesh, reader, owner); // _normalData
LoadObject(mesh, reader, owner); // _colorData
LoadObject(mesh, reader, owner); // _secondaryColorData
LoadObject(mesh, reader, owner); // _fogCoordData
uint numArrayData = reader.ReadUInt32(); // _texCoordList
for (uint i = 0; i < numArrayData; ++i)
{
LoadObject(mesh, reader, owner);
}
numArrayData = reader.ReadUInt32(); // _vertexAttribList
for (uint i = 0; i < numArrayData; ++i)
{
LoadObject(mesh, reader, owner);
}
}
bool hasFastPath = reader.ReadBoolean(); // _fastPathHint
if (hasFastPath)
{
bool fastPathHint = reader.ReadBoolean();
}
// Mesh related components
mesh.RecalculateBounds();
parentObj.AddComponent <MeshFilter>().sharedMesh = mesh;
if (mesh.vertexCount > 3)
{
MeshCollider collider = parentObj.AddComponent <MeshCollider>();
collider.sharedMesh = mesh;
collider.convex = true;
}
MeshRenderer renderer = parentObj.AddComponent <MeshRenderer>();
renderer.sharedMaterial = GameObject.Instantiate <Material>(owner._template);
renderer.sharedMaterial.mainTexture = owner._preloadedTexture;
return(true);
}
void readPrimitive(Mesh mesh, BinaryReader reader, ReaderOSGB owner)
{
int type = reader.ReadInt32();
int mode = reader.ReadInt32();
if (owner._version > 96)
{
uint numInstances = reader.ReadUInt32();
}
List <int> indices = new List <int>();
switch (type)
{
case 50: // ID_DRAWARRAYS
{
int first = reader.ReadInt32();
int count = reader.ReadInt32();
}
break;
case 51: // ID_DRAWARRAY_LENGTH
{
int first = reader.ReadInt32();
uint numArrays = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint n = 0; n < numArrays; ++n)
{
int value = reader.ReadInt32();
}
}
break;
case 52: // ID_DRAWELEMENTS_UBYTE
{
uint numElements = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint n = 0; n < numElements; ++n)
{
uint value = reader.ReadByte();
indices.Add((int)value);
}
}
break;
case 53: // ID_DRAWELEMENTS_USHORT
{
uint numElements = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint n = 0; n < numElements; ++n)
{
uint value = reader.ReadUInt16();
indices.Add((int)value);
}
}
break;
case 54: // ID_DRAWELEMENTS_UINT
{
uint numElements = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint n = 0; n < numElements; ++n)
{
uint value = reader.ReadUInt32();
indices.Add((int)value);
}
}
break;
default: break;
}
// TODO: just a temperatory method to enable triangles applied
if (mesh.vertices.Length < indices.Count)
{
mesh.vertices = new Vector3[indices.Count];
}
// TODO: implement mode other than triangles
mesh.triangles = indices.ToArray();
}
byte[] readArray(BinaryReader reader, ReaderOSGB owner,
ref int numComponents, ref int dataSize, ref int arraySize)
{
if (owner._version < 112)
{
uint id = reader.ReadUInt32();
int type = reader.ReadInt32();
switch (type)
{
case 0: numComponents = 1; dataSize = 1; break; // ID_BYTE_ARRAY
case 1: numComponents = 1; dataSize = 1; break; // ID_UBYTE_ARRAY
case 2: numComponents = 1; dataSize = 2; break; // ID_SHORT_ARRAY
case 3: numComponents = 1; dataSize = 2; break; // ID_USHORT_ARRAY
case 4: numComponents = 1; dataSize = 4; break; // ID_INT_ARRAY
case 5: numComponents = 1; dataSize = 4; break; // ID_UINT_ARRAY
case 6: numComponents = 1; dataSize = 4; break; // ID_FLOAT_ARRAY
case 7: numComponents = 1; dataSize = 8; break; // ID_DOUBLE_ARRAY
case 8: numComponents = 2; dataSize = 1; break; // ID_VEC2B_ARRAY
case 9: numComponents = 3; dataSize = 1; break; // ID_VEC3B_ARRAY
case 10: numComponents = 4; dataSize = 1; break; // ID_VEC4B_ARRAY
case 11: numComponents = 4; dataSize = 1; break; // ID_VEC4UB_ARRAY
case 12: numComponents = 2; dataSize = 2; break; // ID_VEC2S_ARRAY
case 13: numComponents = 3; dataSize = 2; break; // ID_VEC3S_ARRAY
case 14: numComponents = 4; dataSize = 2; break; // ID_VEC4S_ARRAY
case 15: numComponents = 2; dataSize = 4; break; // ID_VEC2_ARRAY
case 16: numComponents = 3; dataSize = 4; break; // ID_VEC3_ARRAY
case 17: numComponents = 4; dataSize = 4; break; // ID_VEC4_ARRAY
case 18: numComponents = 2; dataSize = 8; break; // ID_VEC2D_ARRAY
case 19: numComponents = 3; dataSize = 8; break; // ID_VEC3D_ARRAY
case 20: numComponents = 4; dataSize = 8; break; // ID_VEC4D_ARRAY
case 21: numComponents = 2; dataSize = 1; break; // ID_VEC2UB_ARRAY
case 22: numComponents = 3; dataSize = 1; break; // ID_VEC3UB_ARRAY
case 23: numComponents = 2; dataSize = 2; break; // ID_VEC2US_ARRAY
case 24: numComponents = 3; dataSize = 2; break; // ID_VEC3US_ARRAY
case 25: numComponents = 4; dataSize = 2; break; // ID_VEC4US_ARRAY
case 26: numComponents = 2; dataSize = 4; break; // ID_VEC2I_ARRAY
case 27: numComponents = 3; dataSize = 4; break; // ID_VEC3I_ARRAY
case 28: numComponents = 4; dataSize = 4; break; // ID_VEC4I_ARRAY
case 29: numComponents = 2; dataSize = 4; break; // ID_VEC2UI_ARRAY
case 30: numComponents = 3; dataSize = 4; break; // ID_VEC3UI_ARRAY
case 31: numComponents = 4; dataSize = 4; break; // ID_VEC4UI_ARRAY
default: break;
}
arraySize = reader.ReadInt32();
long blockSize = ReadBracket(reader, owner);
return(reader.ReadBytes(arraySize * numComponents * dataSize));
}
else
{
} // TODO
return(null);
}
public static Texture2D LoadImage(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
Texture2D tex2D = null;
if (owner._version > 94)
{
string className = ReadString(reader);
}
uint id = reader.ReadUInt32();
if (owner._sharedTextures.ContainsKey(id))
{
return(owner._sharedTextures[id]);
}
string fileName = ReadString(reader);
int writeHint = reader.ReadInt32();
int decision = reader.ReadInt32();
switch (decision)
{
case 0: // IMAGE_INLINE_DATA
{
int origin = reader.ReadInt32();
int s = reader.ReadInt32();
int t = reader.ReadInt32();
int r = reader.ReadInt32();
int internalFormat = reader.ReadInt32();
int pixelFormat = reader.ReadInt32();
int dataType = reader.ReadInt32();
int packing = reader.ReadInt32();
int mode = reader.ReadInt32();
uint size = reader.ReadUInt32();
if (size > 0)
{
byte[] imageData = reader.ReadBytes((int)size);
TextureFormat format = TextureFormat.RGB24; // TODO: other formats/data size
if (pixelFormat == 0x1908)
{
format = TextureFormat.RGBA32; // GL_RGBA
}
tex2D = new Texture2D(s, r, format, false);
tex2D.LoadRawTextureData(imageData);
tex2D.Apply();
}
uint numLevels = reader.ReadUInt32();
for (uint i = 0; i < numLevels; ++i)
{
uint levelDataSize = reader.ReadUInt32();
// TODO
}
}
break;
case 1: // IMAGE_INLINE_FILE
{
uint size = reader.ReadUInt32();
if (size > 0)
{
byte[] fileData = reader.ReadBytes((int)size);
tex2D = new Texture2D(2, 2);
tex2D.LoadImage(fileData);
//File.WriteAllBytes("test.jpg", fileData);
}
}
break;
case 2: // IMAGE_EXTERNAL
if (File.Exists(fileName))
{
byte[] fileData = File.ReadAllBytes(fileName);
tex2D = new Texture2D(2, 2);
tex2D.LoadImage(fileData);
}
break;
default: break;
}
osg_Object classObj = new osg_Object();
classObj.read(gameObj, reader, owner);
owner._sharedTextures[id] = tex2D;
return(tex2D);
}
public virtual bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
Debug.LogWarning("Method read() not implemented"); return(false);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
if (!base.read(gameObj, reader, owner))
{
return(false);
}
bool hasWrap = reader.ReadBoolean(); // _wrap_s
if (hasWrap)
{
int wrapS = reader.ReadInt32();
}
hasWrap = reader.ReadBoolean(); // _wrap_r
if (hasWrap)
{
int wrapR = reader.ReadInt32();
}
hasWrap = reader.ReadBoolean(); // _wrap_t
if (hasWrap)
{
int wrapT = reader.ReadInt32();
}
bool hasFilter = reader.ReadBoolean(); // _min_filter
if (hasFilter)
{
int minFilter = reader.ReadInt32();
}
hasFilter = reader.ReadBoolean(); // _mag_filter
if (hasFilter)
{
int magFilter = reader.ReadInt32();
}
float maxAnisotropy = reader.ReadSingle(); // _maxAnisotropy
bool useHardwareMipmap = reader.ReadBoolean(); // _useHardwareMipMapGeneration
bool unrefImageAfterApply = reader.ReadBoolean(); // _unrefImageDataAfterApply
bool clientStorageHint = reader.ReadBoolean(); // _clientStorageHint
bool resizeNPOT = reader.ReadBoolean(); // _resizeNonPowerOfTwoHint
Vector4 borderColor = new Vector4( // _borderColor
(float)reader.ReadDouble(), (float)reader.ReadDouble(),
(float)reader.ReadDouble(), (float)reader.ReadDouble());
int borderWidth = reader.ReadInt32(); // _borderWidth
int formatMode = reader.ReadInt32(); // _internalFormatMode
bool hasInternalFormat = reader.ReadBoolean(); // _internalFormat
if (hasInternalFormat)
{
int internalFormat = reader.ReadInt32();
}
bool hasSourceFormat = reader.ReadBoolean(); // _sourceFormat
if (hasSourceFormat)
{
int sourceFormat = reader.ReadInt32();
}
bool hasSourceType = reader.ReadBoolean(); // _sourceType
if (hasSourceType)
{
int sourceType = reader.ReadInt32();
}
bool useShadowCompare = reader.ReadBoolean(); // _use_shadow_comparison
int shadowCompareFunc = reader.ReadInt32(); // _shadow_compare_func
int shadowTextureMode = reader.ReadInt32(); // _shadow_texture_mode
float shadowAmbient = reader.ReadSingle(); // _shadow_ambient
if (owner._version >= 95 && owner._version < 153)
{
bool hasImageAttachment = reader.ReadBoolean(); // _imageAttachment
if (hasImageAttachment)
{
int unit = reader.ReadInt32();
int level = reader.ReadInt32();
bool layered = reader.ReadBoolean();
int layer = reader.ReadInt32();
int access = reader.ReadInt32();
int format = reader.ReadInt32();
}
}
if (owner._version >= 98)
{
bool hasSwizzle = reader.ReadBoolean(); // _swizzle
if (hasSwizzle)
{
string swizzle = ReadString(reader);
}
}
if (owner._version >= 155)
{
float minLOD = reader.ReadSingle(); // _minLOD
float maxLOD = reader.ReadSingle(); // _maxLOD
float lodBias = reader.ReadSingle(); // _lodBias
}
return(true);
}
public override bool read(Object gameObj, BinaryReader reader, ReaderOSGB owner)
{
GameObject parentObj = gameObj as GameObject;
if (!base.read(gameObj, reader, owner))
{
return(false);
}
PagedData pagedData = parentObj.GetComponent <PagedData>();
pagedData._rootFileName = owner._currentFileName;
bool hasPath = reader.ReadBoolean(); // _databasePath
if (hasPath)
{
bool notEmptyPath = reader.ReadBoolean();
if (notEmptyPath)
{
string databasePath = ReadString(reader);
if (pagedData != null)
{
pagedData._databasePath = databasePath;
}
}
}
//int numFrames = reader.ReadInt32(); // _frameNumberOfLastTraversal
int numExpired = reader.ReadInt32(); // _numChildrenThatCannotBeExpired
bool disableExternalPaging = reader.ReadBoolean(); // _disableExternalChildrenPaging
bool hasRangeData = reader.ReadBoolean(); // _perRangeDataList
if (hasRangeData)
{
uint numRanges = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numRanges; ++i)
{
string pagedFile = ReadString(reader);
if (pagedData != null)
{
pagedData._fileNames.Add(pagedFile);
}
}
uint numPriorityOffsets = reader.ReadUInt32();
blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numPriorityOffsets; ++i)
{
float offset = reader.ReadSingle();
float scale = reader.ReadSingle();
}
}
bool hasChildren = reader.ReadBoolean(); // _children (preloaded)
if (hasChildren)
{
uint numChildren = reader.ReadUInt32();
long blockSize = ReadBracket(reader, owner);
for (uint i = 0; i < numChildren; ++i)
{
GameObject children = new GameObject("Child_" + i.ToString());
if (parentObj && LoadObject(children, reader, owner))
{
children.transform.SetParent(parentObj.transform, false);
}
if (pagedData != null)
{
pagedData._pagedNodes.Add(children);
}
}
}
return(true);
}
