public TextureImporter(AssetLayout layout) :
base(layout)
{
EnableMipMap = 1;
SRGBTexture = 1;
AlphaTestReferenceValue = 0.5f;
MipMapFadeDistanceStart = 1;
MipMapFadeDistanceEnd = 3;
HeightScale = 0.25f;
GenerateCubemap = TextureImporterGenerateCubemap.AutoCubemap;
TextureFormat = TextureFormat.Alpha8;
MaxTextureSize = 2048;
TextureSettings = new GLTextureSettings(layout);
NPOTScale = TextureImporterNPOTScale.ToNearest;
CompressionQuality = 50;
SpriteMode = SpriteImportMode.Single;
SpriteExtrude = 1;
SpriteMeshType = SpriteMeshType.Tight;
SpritePivot = new Vector2f(0.5f, 0.5f);
SpritePixelsToUnits = 100.0f;
SpriteGenerateFallbackPhysicsShape = 1;
AlphaUsage = TextureImporterAlphaSource.FromInput;
AlphaIsTransparency = 0;
SpriteTessellationDetail = -1;
TextureShape = TextureImporterShape.Texture2D;
PlatformSettings = new TextureImporterPlatformSettings[] { new TextureImporterPlatformSettings(layout) };
SpriteSheet = new SpriteSheetMetaData(layout);
SpritePackingTag = string.Empty;
Output = new TextureImportOutput(layout);
}
protected AnimatorTransitionBase(AssetLayout layout, AssetInfo assetInfo, BaseParameters parameters) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
List <AnimatorCondition> conditionList = new List <AnimatorCondition>(parameters.ConditionConstants.Count);
for (int i = 0; i < parameters.ConditionConstants.Count; i++)
{
ConditionConstant conditionConstant = parameters.ConditionConstants[i].Instance;
if (conditionConstant.ConditionMode != AnimatorConditionMode.ExitTime)
{
AnimatorCondition condition = new AnimatorCondition(conditionConstant, parameters.TOS);
conditionList.Add(condition);
}
}
Conditions = conditionList.ToArray();
AnimatorState state = parameters.GetDestinationState();
DstStateMachine = default;
DstState = state == null ? default : state.File.CreatePPtr(state);
Name = parameters.Name;
Solo = false;
Mute = false;
IsExit = parameters.IsExit;
}
protected AssetImporter(AssetLayout layout) :
base(layout)
{
if (IncludesIDToName)
{
if (HasInternalIDToNameTable(layout.Info.Version))
{
InternalIDToNameTable = new Dictionary <Tuple <ClassIDType, long>, string>();
}
else if (FileIDToRecycleNameRelevant(layout.Info.Version))
{
FileIDToRecycleName = new Dictionary <long, string>();
}
}
if (HasExternalObjects(layout.Info.Version))
{
ExternalObjects = new Dictionary <SourceAssetIdentifier, PPtr <Object> >();
}
if (HasUsedFileIDs(layout.Info.Version))
{
UsedFileIDs = Array.Empty <long>();
}
UserData = string.Empty;
AssetBundleName = string.Empty;
AssetBundleVariant = string.Empty;
}
public IHVImageFormatImporter(AssetLayout layout) :
base(layout)
{
TextureSettings.FilterMode = FilterMode.Bilinear;
TextureSettings.Aniso = 1;
SRGBTexture = true;
}
private BlendTree(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, StateConstant state, int nodeIndex) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
BlendTreeNodeConstant node = state.GetBlendTree().NodeArray[nodeIndex].Instance;
Name = nameof(BlendTree);
Childs = new ChildMotion[node.ChildIndices.Length];
for (int i = 0; i < node.ChildIndices.Length; i++)
{
Childs[i] = new ChildMotion(virtualFile, controller, state, nodeIndex, i);
}
BlendParameter = node.BlendEventID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventID];
BlendParameterY = node.BlendEventYID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventYID];
MinThreshold = node.GetMinThreshold(controller.File.Version);
MaxThreshold = node.GetMaxThreshold(controller.File.Version);
UseAutomaticThresholds = false;
NormalizedBlendValues = node.BlendDirectData.Instance.NormalizedBlendValues;
BlendType = node.BlendType;
}
private static void FindMinMaxBounds(AssetLayout layout, Mesh mesh, ref SubMesh submesh, out Vector3f min, out Vector3f max)
{
if (Mesh.HasCompressedMesh(layout.Info.Version))
{
if (mesh.CompressedMesh.Vertices.IsSet)
{
float[] vertices = mesh.CompressedMesh.Vertices.Unpack();
FindMinMaxBounds(vertices, submesh.FirstVertex, submesh.VertexCount, out min, out max);
return;
}
}
if (Mesh.HasVertexData(layout.Info.Version))
{
if (Mesh.IsOnlyVertexData(layout.Info.Version))
{
FindMinMaxBounds(layout, ref mesh.VertexData, submesh.FirstVertex, submesh.VertexCount, out min, out max);
}
else
{
if (mesh.MeshCompression == MeshCompression.Off)
{
FindMinMaxBounds(layout, ref mesh.VertexData, submesh.FirstVertex, submesh.VertexCount, out min, out max);
}
else
{
FindMinMaxBounds(mesh.Vertices, submesh.FirstVertex, submesh.VertexCount, out min, out max);
}
}
}
else
{
FindMinMaxBounds(mesh.Vertices, submesh.FirstVertex, submesh.VertexCount, out min, out max);
}
}
private void WriteBlob(AssetLayout layout, MemoryStream memStream, out uint compressedLength, out uint decompressedLength, int segment)
{
using (MemoryStream blobMem = new MemoryStream())
{
using (AssetWriter blobWriter = new AssetWriter(blobMem, EndianType.LittleEndian, layout))
{
if (segment == 0)
{
blobWriter.WriteAssetArray(Entries);
}
WriteSegment(blobWriter, segment);
}
decompressedLength = (uint)blobMem.Length;
blobMem.Position = 0;
#warning TODO:
compressedLength = 0;
/*using (Lz4EncodeStream lz4Stream = new Lz4EncodeStream(blobMem, blobMem.Length))
* {
* lz4Stream.Write(memStream);
* compressedLength = lz4Stream.Length;
* }*/
}
}
public MonoFieldContext(FieldDefinition field, IReadOnlyDictionary <GenericParameter, TypeReference> arguments, AssetLayout layout)
{
Layout = layout;
Definition = field;
ElementType = field.FieldType;
IsArray = false;
Arguments = arguments;
}
public MonoImporter(AssetLayout layout) :
base(layout)
{
if (HasDefaultReferences(layout.Info.Version))
{
DefaultReferences = new Dictionary <string, PPtr <Object> >();
}
}
public ScriptExportManager(AssetLayout layout, string exportPath)
{
if (string.IsNullOrEmpty(exportPath))
{
throw new ArgumentNullException(nameof(exportPath));
}
Layout = layout;
m_exportPath = exportPath;
}
public AssetLayout GetLayout(LayoutInfo info)
{
if (!m_layouts.TryGetValue(info, out AssetLayout value))
{
value = new AssetLayout(info);
m_layouts.Add(info, value);
}
return(value);
}
public GLTextureSettings(AssetLayout layout)
{
FilterMode = (FilterMode)(-1);
Aniso = -1;
MipBias = -100;
WrapU = (TextureWrapMode)(-1);
WrapV = (TextureWrapMode)(-1);
WrapW = (TextureWrapMode)(-1);
}
private AnimatorStateMachine(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex) :
base(layout)
{
AssetInfo = assetInfo;
ObjectHideFlags = HideFlags.HideInHierarchy;
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
int layerIndex = controller.Controller.GetLayerIndexByStateMachineIndex(stateMachineIndex);
ref LayerConstant layer = ref controller.Controller.LayerArray[layerIndex].Instance;
public static GameCollection CreateGameCollection()
{
var layoutInfo = new LayoutInfo(new Version(), Platform.StandaloneWin64Player, TransferInstructionFlags.NoTransferInstructionFlags);
var layout = new AssetLayout(layoutInfo);
var parameters = new GameCollection.Parameters(layout);
parameters.ScriptBackend = ScriptingBackend.Mono;
var gameCollection = new GameCollection(parameters);
return(gameCollection);
}
private AnimatorStateTransition(AssetLayout layout, AssetInfo assetInfo, Parameters parameters) :
base(layout, assetInfo, parameters)
{
TransitionDuration = parameters.Transition.TransitionDuration;
TransitionOffset = parameters.Transition.TransitionOffset;
ExitTime = parameters.Transition.GetExitTime(parameters.Version);
HasExitTime = parameters.Transition.GetHasExitTime(parameters.Version);
HasFixedDuration = parameters.Transition.GetHasFixedDuration(parameters.Version);
InterruptionSource = parameters.Transition.GetInterruptionSource(parameters.Version);
OrderedInterruption = parameters.Transition.OrderedInterruption;
CanTransitionToSelf = parameters.Transition.CanTransitionToSelf;
}
public static TypeTree GenerateTypeTree(AssetLayout layout, SerializableType origin)
{
TypeTreeContext context = new TypeTreeContext(layout);
GenerateTypeTree(context, origin);
TypeTree instance = new TypeTree();
instance.Nodes = context.Nodes.ToArray();
instance.CustomTypeBuffer = Array.Empty <byte>();
return(instance);
}
private void Load(List <string> pathes, LayoutInfo layinfo)
{
if (CheckPC(pathes))
{
}
else if (CheckLinux(pathes))
{
}
else if (CheckMac(pathes))
{
}
else if (CheckAndroid(pathes))
{
}
else if (CheckiOS(pathes))
{
}
else if (CheckSwitch(pathes))
{
}
else if (CheckWebGL(pathes))
{
}
else if (CheckWebPlayer(pathes))
{
}
CheckMixed(pathes);
using (GameStructureProcessor processor = new GameStructureProcessor())
{
if (PlatformStructure != null)
{
ProcessPlatformStructure(processor, PlatformStructure);
}
if (MixedStructure != null)
{
ProcessPlatformStructure(processor, MixedStructure);
}
processor.AddDependencySchemes(RequestDependency);
if (processor.IsValid)
{
layinfo = layinfo ?? processor.GetLayoutInfo();
AssetLayout layout = new AssetLayout(layinfo);
GameCollection.Parameters pars = new GameCollection.Parameters(layout);
pars.ScriptBackend = GetScriptingBackend();
pars.RequestAssemblyCallback = OnRequestAssembly;
pars.RequestResourceCallback = OnRequestResource;
FileCollection = new GameCollection(pars);
processor.ProcessSchemes(FileCollection);
}
}
}
public void Read(AssetLayout layout, MemoryStream memStream, uint[] offsets, uint[] compressedLengths, uint[] decompressedLengths)
{
for (int i = 0; i < offsets.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
memStream.Position = offset;
ReadBlob(layout, memStream, compressedLength, decompressedLength, i);
}
}
private static void FindMinMaxBounds(AssetLayout layout, ref VertexData vertexData, int firstVertex, int vertexCount, out Vector3f min, out Vector3f max)
{
ChannelInfo channel = vertexData.GetChannel(layout.Info.Version, ShaderChannel.Vertex);
int streamOffset = vertexData.GetStreamOffset(layout.Info.Version, channel.Stream);
int streamStride = vertexData.GetStreamStride(layout.Info.Version, channel.Stream);
int extraStride = streamStride - ShaderChannel.Vertex.GetStride(layout.Info.Version);
int vertexOffset = firstVertex * streamStride;
int begin = streamOffset + vertexOffset + channel.Offset;
using (MemoryStream stream = new MemoryStream(vertexData.Data))
{
using (AssetReader reader = new AssetReader(stream, EndianType.LittleEndian, layout))
{
stream.Position = begin;
Vector3f dummyVertex = reader.ReadAsset <Vector3f>();
min = dummyVertex;
max = dummyVertex;
stream.Position = begin;
for (int i = 0; i < vertexCount; i++)
{
Vector3f vertex = reader.ReadAsset <Vector3f>();
if (vertex.X > max.X)
{
max.X = vertex.X;
}
else if (vertex.X < min.X)
{
min.X = vertex.X;
}
if (vertex.Y > max.Y)
{
max.Y = vertex.Y;
}
else if (vertex.Y < min.Y)
{
min.Y = vertex.Y;
}
if (vertex.Z > max.Z)
{
max.Z = vertex.Z;
}
else if (vertex.Z < min.Z)
{
min.Z = vertex.Z;
}
stream.Position += extraStride;
}
}
}
}
private void UnpackSubProgramBlobs(AssetLayout layout, uint[][] offsets, uint[][] compressedLengths, uint[][] decompressedLengths, byte[] compressedBlob)
{
Blobs = new ShaderSubProgramBlob[offsets.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint[] blobOffsets = offsets[i];
uint[] blobCompressedLengths = compressedLengths[i];
uint[] blobDecompressedLengths = decompressedLengths[i];
Blobs[i].Read(layout, memStream, blobOffsets, blobCompressedLengths, blobDecompressedLengths);
}
}
}
public TextureImporterPlatformSettings(AssetLayout layout)
{
BuildTarget = DefaultTexturePlatformName;
MaxTextureSize = 2048;
ResizeAlgorithm = TextureResizeAlgorithm.Mitchell;
TextureFormat = TextureFormat.Automatic;
TextureCompression = TextureImporterCompression.Uncompressed;
CompressionQuality = 50;
CrunchedCompression = false;
AllowsAlphaSplitting = false;
Overridden = false;
AndroidETC2FallbackOverride = AndroidETC2FallbackOverride.UseBuildSettings;
ForceMaximumCompressionQuality_BC6H_BC7 = false;
}
private static void RecalculateSubmeshBounds(AssetLayout layout, Mesh mesh, ref SubMesh submesh)
{
if (submesh.VertexCount == 0)
{
submesh.LocalAABB = default;
return;
}
FindMinMaxBounds(layout, mesh, ref submesh, out Vector3f min, out Vector3f max);
Vector3f center = (min + max) / 2.0f;
Vector3f extent = max - center;
submesh.LocalAABB = new AABB(center, extent);
}
public SpriteSheetMetaData(AssetLayout layout)
{
Sprites = Array.Empty <SpriteMetaData>();
Outline = Array.Empty <Vector2f[]>();
PhysicsShape = Array.Empty <Vector2f[]>();
Bones = Array.Empty <SpriteBone>();
SpriteID = string.Empty;
InternalID = 0;
Vertices = Array.Empty <Vector2f>();
Indices = Array.Empty <int>();
Edges = Array.Empty <Int2Storage>();
Weights = Array.Empty <BoneWeights4>();
SecondaryTextures = Array.Empty <SecondarySpriteTexture>();
}
private void ReadSubProgramBlobs(AssetLayout layout, uint[] offsets, uint[] compressedLengths, uint[] decompressedLengths, byte[] compressedBlob)
{
SubProgramBlobs = new ShaderSubProgramBlob[Platforms.Length];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
for (int i = 0; i < Platforms.Length; i++)
{
uint offset = offsets[i];
uint compressedLength = compressedLengths[i];
uint decompressedLength = decompressedLengths[i];
SubProgramBlobs[i] = ReadSubProgramBlobs(layout, memStream, offset, compressedLength, decompressedLength);
}
}
}
public Animation(AssetLayout layout) :
base(layout)
{
AnimationLayout classLayout = layout.Animation;
if (classLayout.HasAnimations)
{
Animations = Array.Empty <PPtr <AnimationClip> >();
}
else
{
AnimationsPaired = Array.Empty <Tuple <string, PPtr <AnimationClip> > >();
}
PlayAutomatically = true;
}
public GUIStyle(AssetLayout layout) :
this()
{
Name = string.Empty;
Normal = new GUIStyleState(layout);
Hover = new GUIStyleState(layout);
Active = new GUIStyleState(layout);
Focused = new GUIStyleState(layout);
OnNormal = new GUIStyleState(layout);
OnHover = new GUIStyleState(layout);
OnActive = new GUIStyleState(layout);
OnFocused = new GUIStyleState(layout);
FontSize = 33;
RichText = true;
TextClipping = layout.Info.Version.IsGreaterEqual(4) ? TextClipping.Overflow : TextClipping.Clip;
StretchWidth = true;
}
public GameObject(AssetLayout layout) :
base(layout)
{
GameObjectLayout classLayout = layout.GameObject;
if (classLayout.IsComponentTuple)
{
ComponentTuple = Array.Empty <Tuple <ClassIDType, PPtr <Component> > >();
}
else
{
Component = Array.Empty <ComponentPair>();
}
Name = string.Empty;
TagString = TagManager.UntaggedTag;
IsActive = true;
}
public void Write(AssetLayout layout, MemoryStream memStream, out uint[] offsets, out uint[] compressedLengths, out uint[] decompressedLengths)
{
int segmentCount = Entries.Length == 0 ? 0 : Entries.Max(t => t.Segment) + 1;
offsets = new uint[segmentCount];
compressedLengths = new uint[segmentCount];
decompressedLengths = new uint[segmentCount];
for (int i = 0; i < segmentCount; i++)
{
uint offset = (uint)memStream.Position;
WriteBlob(layout, memStream, out uint compressedLength, out uint decompressedLength, i);
offsets[i] = offset;
compressedLengths[i] = compressedLength;
decompressedLengths[i] = decompressedLength;
}
}
private void UnpackSubProgramBlobs(AssetLayout layout, uint offset, uint compressedLength, uint decompressedLength, byte[] compressedBlob)
{
if (compressedBlob.Length == 0)
{
Blobs = Array.Empty <ShaderSubProgramBlob>();
}
else
{
Blobs = new ShaderSubProgramBlob[1];
using (MemoryStream memStream = new MemoryStream(compressedBlob))
{
uint[] offsets = new uint[] { offset };
uint[] compressedLengths = new uint[] { compressedLength };
uint[] decompressedLengths = new uint[] { decompressedLength };
Blobs[0].Read(layout, memStream, offsets, compressedLengths, decompressedLengths);
}
}
}
private ShaderSubProgramBlob ReadSubProgramBlobs(AssetLayout layout, MemoryStream memStream, uint offset, uint compressedLength, uint decompressedLength)
{
memStream.Position = offset;
byte[] decompressedBuffer = new byte[decompressedLength];
using (Lz4DecodeStream lz4Stream = new Lz4DecodeStream(memStream, (int)compressedLength))
{
lz4Stream.ReadBuffer(decompressedBuffer, 0, decompressedBuffer.Length);
}
using (MemoryStream blobMem = new MemoryStream(decompressedBuffer))
{
using (AssetReader blobReader = new AssetReader(blobMem, EndianType.LittleEndian, layout))
{
ShaderSubProgramBlob blob = new ShaderSubProgramBlob();
blob.Read(blobReader);
return(blob);
}
}
}
