Esempio n. 1
0
    public static GameObject GenObject(this SkyLayer layer, FezUnitySky parent, int index, float offsetScale = 1f)
    {
        float maxSize    = Mathf.Max(FezUnityLevel.Current.Level.Size.x, FezUnityLevel.Current.Level.Size.y, FezUnityLevel.Current.Level.Size.z);
        float sizeFactor = Mathf.Max(1f, maxSize / 32f);
        float offset     = sizeFactor * (index * 32f + FezManager.Instance.SkySpace) * offsetScale;

        GameObject obj = new GameObject(layer.Name);

        obj.transform.parent        = parent.transform;
        obj.transform.localPosition = new Vector3(
            FezUnityLevel.Current.Level.Size.x / 2f,
            FezUnityLevel.Current.Level.Size.y / 2f + offset / 2f,
            FezUnityLevel.Current.Level.Size.z / 2f
            );
        obj.transform.localScale = new Vector3(
            maxSize + offset,
            maxSize + offset,
            maxSize + offset
            );

        FezUnitySkyLayer fezHolder = obj.AddComponent <FezUnitySkyLayer>();

        fezHolder.Fill(parent, layer, index);
        obj.isStatic = true;

        // Fix Unity / Trixel Engine Z direction conflict
        obj.FezZ();

        return(obj);
    }
Esempio n. 2
0
    public void Fill(FezUnitySky sky)
    {
        Sky       = sky.Sky;
        Texture   = sky.Texture;
        FogColors = sky.FogColors;

        Fill();
    }
Esempio n. 3
0
    public FezUnitySky GetUnitySky(string name)
    {
        FezUnityLevel level = FezUnityLevel.Current;

        // Microoptimization: Sky.Sky - direct access
        if (level != null && level.Sky != null && level.Sky.Sky != null && level.Sky.Sky.Name == name)
        {
            return(level.Sky);
        }

        FezUnitySky uSky;

        if (UnitySkies.TryGetValue(name, out uSky))
        {
            return(uSky);
        }

        return(UnitySkies[name] = new FezUnitySky(GetFezSky(name)));
    }
Esempio n. 4
0
    public IEnumerator FillCoroutine(Level level)
    {
        Level = level;

        if (string.IsNullOrEmpty(name))
        {
            name = level.Name;

            //Offset the triles and everything back
            transform.position -= FezHelper.TrileOffset;
        }

        Triles.Clear();
        ArtObjects.Clear();

        if (chunksObj != null)
        {
            Destroy(chunksObj);
        }
        chunksObj = new GameObject("Chunks");
        chunksObj.transform.parent = transform;
        chunksObj.isStatic         = true;
        chunks.Clear();

        TrileSet       = FezManager.Instance.GetUnityTrileSet(level.TrileSetName);
        level.TrileSet = TrileSet.TrileSet;
        yield return(null);

        if (level.SkyName != null)
        {
            GameObject skyObj = new GameObject("Sky (" + level.SkyName + ")");
            skyObj.transform.parent = transform;
            Sky = skyObj.AddComponent <FezUnitySky>();
            Sky.Fill(FezManager.Instance.GetUnitySky(level.SkyName));
            yield return(null);
        }

        if (SetupLightingOnFill)
        {
            SetupLighting();
        }

        if (level.WaterType != LiquidType.None)
        {
            GameObject waterObj = new GameObject("Water");
            waterObj.transform.parent        = transform;
            waterObj.transform.localPosition = new Vector3(level.Size.x / 2f, level.WaterHeight, level.Size.z / -2f);
            Water = waterObj.AddComponent <FezUnityWater>();
            Water.Fill(level.WaterType);
        }

        int asset = 0;

        GameObject trilesObj = new GameObject("Triles");

        trilesObj.transform.parent    = transform;
        trilesObj.transform.position += FezHelper.TrileOffset;
        foreach (KeyValuePair <TrileEmplacement, TrileInstance> pair in level.Triles)
        {
            TrileInstance trile = pair.Value;
            if (trile.TrileId == -1)
            {
                continue;
            }
            SetTrileInInstance(trile);
            GameObject trileObj = trile.GenObject(trilesObj);

            Triles[pair.Key] = trileObj;

            if (IsHidden(trile.Emplacement))
            {
                trileObj.SetActive(false);
            }
            else
            {
                AddToChunk(trileObj);
                asset++;
            }

            if (asset >= AssetsPerFrame)
            {
                asset = 0;
                yield return(pair);
            }
            else
            {
                asset++;
            }
        }

        GameObject aosObj = new GameObject("Art Objects");

        aosObj.transform.parent = transform;
        foreach (KeyValuePair <int, ArtObjectInstance> pair in level.ArtObjects)
        {
            ArtObjectInstance ao = pair.Value;
            ao.ArtObject         = FezManager.Instance.GetArtObject(ao.ArtObjectName);
            ArtObjects[pair.Key] = ao.GenObject(aosObj);

            if (asset >= AssetsPerFrame)
            {
                asset = 0;
                yield return(pair);
            }
            else
            {
                asset++;
            }
        }

        GameObject planesObj = new GameObject("Background Planes");

        planesObj.transform.parent = transform;
        foreach (KeyValuePair <int, BackgroundPlane> pair in level.BackgroundPlanes)
        {
            BackgroundPlane plane = pair.Value;
            BackgroundPlanes[pair.Key] = plane.GenObject(planesObj);

            if (asset >= AssetsPerFrame)
            {
                asset = 0;
                yield return(pair);
            }
            else
            {
                asset++;
            }
        }

        GameObject npcsObj = new GameObject("NPCs");

        npcsObj.transform.parent = transform;
        foreach (KeyValuePair <int, NpcInstance> pair in level.NonPlayerCharacters)
        {
            NpcInstance npc = pair.Value;
            NPCs[pair.Key] = npc.GenObject(npcsObj);

            if (asset >= AssetsPerFrame)
            {
                asset = 0;
                yield return(pair);
            }
            else
            {
                asset++;
            }
        }

        asset = 0;
        IEnumerator buildc = BuildChunks();

        while (buildc.MoveNext())
        {
            if (asset >= ChunksPerFrame)
            {
                asset = 0;
                yield return(buildc.Current);
            }
            else
            {
                asset++;
            }
        }
    }