//-------Trile Sets-------
public static void LoadTrileSet(string toLoad)
{
if (IsSetLoaded(toLoad))
{
return;
}
string filePathXNB = OutputPath.OutputPathDir + "trile sets/" + toLoad + ".xnb";
if (!File.Exists(filePathXNB))
{
Debug.LogError("No model!");
return;
}
//---Set loader---
TrileSet loadedSet = (TrileSet)FmbUtil.ReadObject(filePathXNB);
loadedSet.TextureAtlas.filterMode = FilterMode.Point;
/*//---Image loader---
* Texture2D tilesetTexture = new Texture2D(1, 1);
* byte[] image = File.ReadAllBytes(texturePath);
*
* tilesetTexture.LoadImage(image);
* tilesetTexture.filterMode=FilterMode.Point;
*
* //Assign texture to set
* //TODO, add materials somehow so we don't always need new ones
* loadedSet.TextureAtlas=tilesetTexture;*/
loadedSets.Add(toLoad, loadedSet);
}
public override object Read(BinaryReader reader, bool xnb)
{
AnimatedTexture obj = new AnimatedTexture();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
obj.FrameWidth = reader.ReadInt32();
obj.FrameHeight = reader.ReadInt32();
int dataSize = reader.ReadInt32();
Texture2D texture = Texture2DHandler.GenTexture(width, height, SurfaceFormat.Color, 1);
#if XNA
//For XNA, we simply pass the data for the only level.
texture.SetData(0, null, reader.ReadBytes(dataSize), 0, dataSize);
#elif UNITY
//Oh, Unity, wh~ oh, just one level. Continue on.
texture.LoadRawTextureData(Texture2DHandler.Remap(reader.ReadBytes(dataSize), SurfaceFormat.Color));
//updateMipmaps is true by default; makeNoLongerReadable should be false.
texture.Apply(false, FmbUtil.Setup.TexturesWriteOnly);
#endif
obj.Texture = texture;
FrameContent[] list = FmbUtil.ReadObject <List <FrameContent> >(reader, xnb).ToArray();
obj.Offsets = FmbHelper.Select <FrameContent, Rectangle>(list, delegate(FrameContent x) { return(x.Rectangle); });
obj.Timing = new AnimationTiming(0, list.Length - 1, FmbHelper.Select <FrameContent, float>(list, delegate(FrameContent x) { return((float)x.Duration.TotalSeconds); }));
obj.PotOffset = new Vector2((float)(FmbHelper.NextPowerOfTwo(obj.FrameWidth) - obj.FrameWidth), (float)(FmbHelper.NextPowerOfTwo(obj.FrameHeight) - obj.FrameHeight));
return(obj);
}
//-------Art Objects-------
public static void LoadAO(string toLoad)
{
if (IsAOLoaded(toLoad))
{
return;
}
string filePathXNB = OutputPath.OutputPathDir + "art objects/" + toLoad + ".xnb";
if (!File.Exists(filePathXNB))
{
Debug.LogError("No model!");
return;
}
//---AO loader---
ArtObject loaded = (ArtObject)FmbUtil.ReadObject(filePathXNB);
loaded.Cubemap.filterMode = FilterMode.Point;
/*/---Image loader---
* Texture2D texture = new Texture2D(1, 1);
* byte[] image = File.ReadAllBytes(texturePath);
*
* texture.LoadImage(image);
* texture.filterMode=FilterMode.Point;
*
* //Assign texture to set
* //TODO, add materials somehow so we don't always need new ones
* loaded.Cubemap=texture;*/
loadedArtObjects.Add(toLoad, loaded);
}
public override object Read(BinaryReader reader, bool xnb)
{
BackgroundPlane obj = new BackgroundPlane();
obj.Position = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.Rotation = FmbUtil.ReadObject <Quaternion>(reader, xnb, false);
obj.Scale = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.Size = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.TextureName = reader.ReadString();
obj.LightMap = reader.ReadBoolean();
obj.AllowOverbrightness = reader.ReadBoolean();
obj.Filter = FmbUtil.ReadObject <Color>(reader, xnb, false);
obj.Animated = reader.ReadBoolean();
obj.Doublesided = reader.ReadBoolean();
obj.Opacity = reader.ReadSingle();
obj.AttachedGroup = FmbUtil.ReadObject <int?>(reader, xnb);
obj.Billboard = reader.ReadBoolean();
obj.SyncWithSamples = reader.ReadBoolean();
obj.Crosshatch = reader.ReadBoolean();
reader.ReadBoolean();
obj.AlwaysOnTop = reader.ReadBoolean();
obj.Fullbright = reader.ReadBoolean();
obj.PixelatedLightmap = reader.ReadBoolean();
obj.XTextureRepeat = reader.ReadBoolean();
obj.YTextureRepeat = reader.ReadBoolean();
obj.ClampTexture = reader.ReadBoolean();
obj.ActorType = FmbUtil.ReadObject <ActorType>(reader, xnb);
obj.AttachedPlane = FmbUtil.ReadObject <int?>(reader, xnb);
obj.ParallaxFactor = reader.ReadSingle();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
Sky obj = new Sky();
obj.Name = reader.ReadString();
obj.Background = reader.ReadString();
obj.WindSpeed = reader.ReadSingle();
obj.Density = reader.ReadSingle();
obj.FogDensity = reader.ReadSingle();
obj.Layers = FmbUtil.ReadObject <List <SkyLayer> >(reader, xnb);
obj.Clouds = FmbUtil.ReadObject <List <string> >(reader, xnb);
obj.Shadows = FmbUtil.ReadObject <string>(reader, xnb);
obj.Stars = FmbUtil.ReadObject <string>(reader, xnb);
obj.CloudTint = FmbUtil.ReadObject <string>(reader, xnb);
obj.VerticalTiling = reader.ReadBoolean();
obj.HorizontalScrolling = reader.ReadBoolean();
obj.LayerBaseHeight = reader.ReadSingle();
obj.InterLayerVerticalDistance = reader.ReadSingle();
obj.InterLayerHorizontalDistance = reader.ReadSingle();
obj.HorizontalDistance = reader.ReadSingle();
obj.VerticalDistance = reader.ReadSingle();
obj.LayerBaseSpacing = reader.ReadSingle();
obj.WindParallax = reader.ReadSingle();
obj.WindDistance = reader.ReadSingle();
obj.CloudsParallax = reader.ReadSingle();
obj.ShadowOpacity = reader.ReadSingle();
obj.FoliageShadows = reader.ReadBoolean();
obj.NoPerFaceLayerXOffset = reader.ReadBoolean();
obj.LayerBaseXOffset = reader.ReadSingle();
return(obj);
}
public void LoadArtObject(string name)
{
Debug.Log("Load");
string path = OutputPath.OutputPathDir + "art objects/" + name.ToLower() + ".xnb";
ArtObject aoL = FmbUtil.ReadObject <ArtObject>(path);
if (aoCache.ContainsKey(aoL.Name))
{
return;
}
else
{
aoCache.Add(aoL.Name, aoL);
}
Debug.Log("Cached");
if (!aoMeshCache.ContainsKey(aoL))
{
aoMeshCache.Add(aoL, FezToUnity.ArtObjectToMesh(aoL));
}
ListAOUnderUI();
Debug.Log("Displayed");
}
public override object Read(BinaryReader reader, bool xnb)
{
TrileInstance obj = new TrileInstance();
obj.Position = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.TrileId = reader.ReadInt32();
byte pPhi = reader.ReadByte();
if (pPhi != 137)
{
obj.SetPhiLight(pPhi);
}
else
{
obj.Phi = reader.ReadSingle();
}
//FIXME either this screws up...
bool b = reader.ReadBoolean();
if (b)
{
obj.ActorSettings = FmbUtil.ReadObject <InstanceActorSettings>(reader, xnb);
}
//... or this.
obj.OverlappedTriles = FmbUtil.ReadObject <List <TrileInstance> >(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
MapTree obj = new MapTree();
obj.Root = FmbUtil.ReadObject <MapNode>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
ScriptTrigger obj = new ScriptTrigger();
obj.Object = FmbUtil.ReadObject <Entity>(reader, xnb);
obj.Event = reader.ReadString();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
NpcActionContent obj = new NpcActionContent();
obj.AnimationName = FmbUtil.ReadObject <string>(reader, xnb);
obj.SoundName = FmbUtil.ReadObject <string>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
TrileFace obj = new TrileFace();
obj.Id = FmbUtil.ReadObject <TrileEmplacement>(reader, xnb);
obj.Face = FmbUtil.ReadObject <FaceOrientation>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
DotDialogueLine obj = new DotDialogueLine();
obj.ResourceText = FmbUtil.ReadObject <string>(reader, xnb);
obj.Grouped = reader.ReadBoolean();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
Entity obj = new Entity();
obj.Type = reader.ReadString();
obj.Identifier = FmbUtil.ReadObject <int?>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
SpeechLine obj = new SpeechLine();
obj.Text = FmbUtil.ReadObject <string>(reader, xnb);
obj.OverrideContent = FmbUtil.ReadObject <NpcActionContent>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
FrameContent obj = new FrameContent();
obj.Duration = FmbUtil.ReadObject <TimeSpan>(reader, xnb);
obj.Rectangle = FmbUtil.ReadObject <Rectangle>(reader, xnb);
return(obj);
}
public void LoadUsedArtObjects()
{
foreach (KeyValuePair <int, ArtObjectInstance> ao in loaded.ArtObjects)
{
string path = OutputPath.OutputPathDir + "art objects/" + ao.Value.ArtObjectName.ToLower() + ".xnb";
ArtObject aoL = FmbUtil.ReadObject <ArtObject>(path);
aoCache.Add(ao.Key, aoL);
}
}
public override object Read(BinaryReader reader, bool xnb)
{
MapNodeConnection obj = new MapNodeConnection();
obj.Face = FmbUtil.ReadObject <FaceOrientation>(reader, xnb);
obj.Node = FmbUtil.ReadObject <MapNode>(reader, xnb);
obj.BranchOversize = reader.ReadSingle();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
CameraNodeData obj = new CameraNodeData();
obj.Perspective = reader.ReadBoolean();
obj.PixelsPerTrixel = reader.ReadInt32();
obj.SoundName = FmbUtil.ReadObject <string>(reader, xnb);
return(obj);
}
void Start()
{
foreach (string assetName in AssetMetadata.Map.Keys)
{
if (!assetName.StartsWith("levels\\"))
{
continue;
}
string level = assetName.Substring(7);
Material material;
try {
using (BinaryReader reader = FezManager.Instance.ReadFromPack("other textures\\map_screens\\" + level)) {
material =
Instantiate((FmbUtil.ReadObject(
reader
) as Texture2D).GenMaterial(ButtonShader));
material.SetTexture("_MaskTex", MaskTexture);
}
} catch {
// Normally hidden / inaccessible level
continue;
}
material.mainTextureScale = new Vector2(
1f,
-1f
);
levels.Add(level);
levelMaterials.Add(material);
}
buttons = new FloatingButton[transform.childCount];
for (int i = 0; i < buttons.Length; i++)
{
Transform childTransform = transform.GetChild(i);
FloatingButton button = childTransform.GetComponent <FloatingButton>();
if (button == null)
{
continue;
}
buttons[i] = button;
button.ScaleFadeSpeed = 0f;
if (i <= 0 || buttons.Length - 1 <= i)
{
continue;
}
UpdateButton(button, i - 1 + levelIndex);
}
}
public override object Read(BinaryReader reader, bool xnb)
{
NpcMetadata obj = new NpcMetadata();
obj.WalkSpeed = reader.ReadSingle();
obj.AvoidsGomez = reader.ReadBoolean();
obj.SoundPath = FmbUtil.ReadObject <string>(reader, xnb);
obj.SoundActions = FmbUtil.ReadObject <List <NpcAction> >(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
RectangularTrixelSurfacePart obj = new RectangularTrixelSurfacePart();
obj.Start = reader.Read = TrixelIdentifierReader.ReadTrixelIdentifier();
obj.Orientation = FmbUtil.ReadObject <FaceOrientation>(reader, xnb);
obj.TangentSize = reader.ReadInt32();
obj.BitangentSize = reader.ReadInt32();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
ArtObjectInstance obj = new ArtObjectInstance(reader.ReadString());
obj.Position = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.Rotation = FmbUtil.ReadObject <Quaternion>(reader, xnb, false);
obj.Scale = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.ActorSettings = FmbUtil.ReadObject <ArtObjectActorSettings>(reader, xnb);
return(obj);
}
public IEnumerator LoadLevelCoroutine(string name, bool multithreaded, System.Action <FezUnityLevel> cb)
{
GameObject levelObj = new GameObject("");
levelObj.SetActive(false);
FezUnityLevel level = levelObj.AddComponent <FezUnityLevel>();
using (BinaryReader reader = ReadFromPack("levels/" + name)) {
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
Level levelRaw = null;
if (!multithreaded)
{
sw.Start();
levelRaw = FmbUtil.ReadObject(reader) as Level;
sw.Stop();
yield return(null);
}
else
{
Thread thread = new Thread(delegate() {
sw.Start();
levelRaw = FmbUtil.ReadObject(reader) as Level;
sw.Stop();
});
thread.Name = "FezUnity load raw level " + name;
thread.IsBackground = true;
thread.Start();
while (thread.IsAlive)
{
yield return(null);
}
}
Debug.Log("Level " + levelRaw.Name + " loaded in " + sw.ElapsedMilliseconds + " ms");
long timeLoad = sw.ElapsedMilliseconds;
sw.Start();
IEnumerator fillc = level.FillCoroutine(levelRaw);
while (fillc.MoveNext())
{
yield return(fillc.Current);
}
sw.Stop();
long timeFill = sw.ElapsedMilliseconds;
Debug.Log("Level " + levelRaw.Name + " filled in " + sw.ElapsedMilliseconds + " ms");
Debug.Log("Level " + levelRaw.Name + " loaded and filled in " + (timeLoad + timeFill) + " ms");
}
levelObj.SetActive(true);
yield return(level);
cb(level);
}
public override object Read(BinaryReader reader, bool xnb)
{
TrileSet obj = new TrileSet();
obj.Name = reader.ReadString();
obj.Triles = FmbUtil.ReadObject <Dictionary <int, Trile> >(reader, xnb);
obj.TextureAtlas = FmbUtil.ReadObject <Texture2D>(reader, xnb);
obj.OnDeserialization();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
Volume obj = new Volume();
obj.Orientations = FmbHelper.HashSetOrList <FaceOrientation>(FmbUtil.ReadObject <FaceOrientation[]>(reader, xnb), FaceOrientationComparer.Default);
obj.From = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.To = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.ActorSettings = FmbUtil.ReadObject <VolumeActorSettings>(reader, xnb);
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
AmbienceTrack obj = new AmbienceTrack();
obj.Name = FmbUtil.ReadObject <string>(reader, xnb);
obj.Dawn = reader.ReadBoolean();
obj.Day = reader.ReadBoolean();
obj.Dusk = reader.ReadBoolean();
obj.Night = reader.ReadBoolean();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
ScriptCondition obj = new ScriptCondition();
obj.Object = FmbUtil.ReadObject <Entity>(reader, xnb);
obj.Operator = FmbUtil.ReadObject <ComparisonOperator>(reader, xnb);
obj.Property = reader.ReadString();
obj.Value = reader.ReadString();
obj.OnDeserialization();
return(obj);
}
public override object Read(BinaryReader reader, bool xnb)
{
MapNode obj = new MapNode();
obj.LevelName = reader.ReadString();
obj.Connections = FmbUtil.ReadObject <List <MapNode.Connection> >(reader, xnb);
obj.NodeType = FmbUtil.ReadObject <LevelNodeType>(reader, xnb);
obj.Conditions = FmbUtil.ReadObject <WinConditions>(reader, xnb);
obj.HasLesserGate = reader.ReadBoolean();
obj.HasWarpGate = reader.ReadBoolean();
return(obj);
}
public ArtObject GetArtObject(string name)
{
ArtObject ao;
if (ArtObjects.TryGetValue(name, out ao))
{
return(ao);
}
using (BinaryReader reader = ReadFromPack("art objects/" + name)) {
return(ArtObjects[name] = FmbUtil.ReadObject(reader) as ArtObject);
}
}
public override object Read(BinaryReader reader, bool xnb)
{
ArtObject obj = new ArtObject();
obj.Name = reader.ReadString();
obj.Cubemap = FmbUtil.ReadObject <Texture2D>(reader, xnb);
obj.Size = FmbUtil.ReadObject <Vector3>(reader, xnb, false);
obj.Geometry = FmbUtil.ReadObject <ShaderInstancedIndexedPrimitives <VertexPositionNormalTextureInstance, Matrix> >(reader, xnb);
obj.ActorType = FmbUtil.ReadObject <ActorType>(reader, xnb);
obj.NoSihouette = reader.ReadBoolean();
return(obj);
}