Exemplo n.º 1
0
        /// <summary>
        /// Create an LBD tilemap GameObject from an LSD level tileset.
        /// </summary>
        /// <param name="lbd">The loaded LBD file.</param>
        /// <returns>A GameObject containing loaded meshes for all tiles in their layout.</returns>
        public GameObject CreateLBDTileMap(LBD lbd, Dictionary <TMDObject, Mesh> cache)
        {
            GameObject             lbdTilemap    = new GameObject("LBD TileMap");
            List <CombineInstance> meshesCreated = new List <CombineInstance>(); // we're combining meshes into a collision mesh

            // for each tile in the tilemap
            int tileNo = 0;

            foreach (LBDTile tile in lbd.TileLayout)
            {
                int x = tileNo / lbd.Header.TileWidth;
                int y = tileNo % lbd.Header.TileWidth;

                // create an LBD tile if we should draw it
                if (tile.DrawTile)
                {
                    GameObject lbdTile = createLBDTile(tile, lbd.ExtraTiles, x, y, lbd.Tiles, meshesCreated, cache);
                    lbdTile.transform.SetParent(lbdTilemap.transform);
                }

                tileNo++;
            }

            // combine all tiles into mesh for efficient collision
            Mesh combined = new Mesh();

            combined.CombineMeshes(meshesCreated.ToArray(), true);
            MeshCollider mc = lbdTilemap.AddComponent <MeshCollider>();

            mc.sharedMesh = combined;

            lbdTilemap.tag = "Linkable";

            return(lbdTilemap);
        }
Exemplo n.º 2
0
        public LBDDocument CreateDocument(LBD lbd)
        {
            TMDDocument        tileTmd    = _tmdController.CreateDocument(lbd.Tiles);
            List <IRenderable> tileLayout = new List <IRenderable>();

            int tileNo = 0;

            foreach (LBDTile tile in lbd.TileLayout)
            {
                int x = tileNo / lbd.Header.TileWidth;
                int y = tileNo % lbd.Header.TileWidth;

                if (tile.DrawTile)
                {
                    tileLayout.AddRange(LibLSDUtil.CreateLBDTileMesh(tile, lbd.ExtraTiles, x, y, lbd.Tiles, _shader,
                                                                     _vramController.VRAMTexture));
                }

                tileNo++;
            }

            List <MOMDocument> entities = null;

            if (lbd.Header.HasMML)
            {
                entities = new List <MOMDocument>();
                foreach (MOM mom in lbd.MML?.MOMs)
                {
                    entities.Add(_momController.CreateDocument(mom));
                }
            }

            return(new LBDDocument(lbd, tileTmd, tileLayout, entities));
        }
Exemplo n.º 3
0
        /// <summary>
        /// Load an LBD file from disk.
        /// </summary>
        /// <param name="path">The path to the LBD file.</param>
        /// <param name="span">The span ID for how long this resource should be cached.</param>
        public void Load(string path, int span)
        {
            LBD lbd;

            using (BinaryReader br = new BinaryReader(File.Open(path, FileMode.Open)))
            {
                lbd = new LBD(br);
            }

            Resource <LBD> resource = new Resource <LBD>(lbd, span);

            ResourceManager.RegisterResource(path, resource);
        }
Exemplo n.º 4
0
        public static LBD LoadLBD(string filePath)
        {
            Log.Information($"Loading LBD from: {filePath}");

            LBD lbd;

            using (BinaryReader br = new BinaryReader(File.Open(filePath, FileMode.Open)))
            {
                lbd = new LBD(br);
            }

            Log.Information("Successfully loaded LBD");
            return(lbd);
        }
Exemplo n.º 5
0
        public static GameObject Create(LBD lbd,
                                        int momIndex,
                                        Material material,
                                        string objName,
                                        int idleAnimation      = 0,
                                        bool playIdleAnimation = false,
                                        string scriptPath      = null)
        {
            if (!lbd.MML.HasValue)
            {
                throw new ArgumentException("Provided LBD did not have entities!", nameof(lbd));
            }

            if (momIndex >= lbd.MML.Value.MOMs.Length)
            {
                throw new ArgumentException(
                          $"LBD only has {lbd.MML.Value.NumberOfMOMs} entities, can't load entity '{momIndex}'");
            }

            if (idleAnimation >= lbd.MML.Value.MOMs[momIndex].MOS.TODs.Length)
            {
                Debug.LogWarning(
                    $"Entity only has {lbd.MML.Value.MOMs[momIndex].MOS.TODs.Length} animations, " +
                    $"can't set idle animation to animation '{idleAnimation}'. Defaulting to '0' instead.");
                idleAnimation = 0;
            }

            GameObject obj     = new GameObject(objName);
            var        objData = new InteractiveObjectData(lbd.MML.Value.MOMs[momIndex], material);

            var animator = obj.AddComponent <TODAnimator>();

            animator.SetAnimation(objData.Animations[idleAnimation]);
            if (playIdleAnimation)
            {
                animator.Resume();
            }

            var objScript = obj.AddComponent <InteractiveObject>();

            objScript.Data = objData;

            // load the Lua script if it's given
            if (!string.IsNullOrEmpty(scriptPath))
            {
                objScript.Script = InteractiveObjectLuaScript.Load(scriptPath, objScript);
            }

            return(obj);
        }
Exemplo n.º 6
0
        private void spawnObject()
        {
            LBD lbd = ResourceManager.Load <LBD>(PathUtil.Combine(Application.streamingAssetsPath, "original", "STG00",
                                                                  "M000.LBD"));

            var texSetOpts = TextureSetOptions.GetFromLBDPath(
                PathUtil.Combine(Application.streamingAssetsPath, "original", "STG00"),
                Shader.Find("LSDR/ClassicDiffuse"),
                Shader.Find("LSDR/RevampedDiffuse"));
            Material mat = new Material(DreamSystem.GetShader(alpha: false));

            DreamSystem.TextureSetSystem.RegisterMaterial(mat, texSetOpts);
            InteractiveObject.Create(lbd, 0, mat, "Head guy", 1, false, "lua/test.lua");
        }
Exemplo n.º 7
0
        public void LoadLBD(string lbdPath)
        {
            Logger.Log()(LogLevel.INFO, $"Loading LBD from: {lbdPath}");

            LBD lbd;

            using (BinaryReader br = new BinaryReader(File.Open(lbdPath, FileMode.Open)))
            {
                lbd = new LBD(br);
            }

            Logger.Log()(LogLevel.INFO, "Successfully loaded LBD");

            LBDDocument document = CreateDocument(lbd);

            _treeController.PopulateTreeWithDocument(document, Path.GetFileName(lbdPath));
        }
        public void LoadLBD(string lbdFolder, LegacyTileMode tileMode, int lbdWidth)
        {
            lbdFolder = PathUtil.Combine(Application.streamingAssetsPath, lbdFolder);

            TextureSetSystem.DeregisterMaterial(LBDDiffuse);
            TextureSetSystem.DeregisterMaterial(LBDAlpha);
            TextureSetSystem.RegisterMaterial(LBDDiffuse,
                                              TextureSetOptions.GetFromLBDPath(lbdFolder, Classic, Revamped));
            TextureSetSystem.RegisterMaterial(LBDAlpha,
                                              TextureSetOptions.GetFromLBDPath(lbdFolder, ClassicAlpha, RevampedAlpha));

            GameObject lbdRenderer  = new GameObject("LBD Renderer");
            LBDTileMap tileMap      = lbdRenderer.AddComponent <LBDTileMap>();
            GameObject lbdColliders = new GameObject("LBD Colliders");

            string[] lbdFiles = Directory.GetFiles(lbdFolder, "*.LBD", SearchOption.AllDirectories);
            LBDColliders = new GameObject[lbdFiles.Length];
            for (int i = 0; i < lbdFiles.Length; i++)
            {
                string lbdFile = lbdFiles[i];

                Vector3 posOffset = Vector3.zero;
                if (tileMode == LegacyTileMode.Horizontal)
                {
                    int xPos = i % lbdWidth;
                    int yPos = i / lbdWidth;
                    int xMod = 0;
                    if (yPos % 2 == 1)
                    {
                        xMod = 10;
                    }

                    posOffset = new Vector3(xPos * 20 - xMod, 0, yPos * 20);
                }

                LBD        lbd         = ResourceManager.Load <LBD>(lbdFile);
                GameObject lbdCollider = createLBDTileMap(lbd, posOffset, tileMap.TileCache);
                lbdCollider.transform.SetParent(lbdColliders.transform);
                LBDColliders[i] = lbdCollider;
            }

            foreach (var m in tileMap.TileCache.Values)
            {
                m.Submit();
            }
        }
Exemplo n.º 9
0
        private void spawnObject()
        {
            if (SpawnedObject != null)
            {
                return;
            }

            var lbdPath    = PathUtil.Combine(Application.streamingAssetsPath, LBDFile);
            LBD lbd        = ResourceManager.Load <LBD>(lbdPath, "scene");
            var texSetOpts = TextureSetOptions.GetFromLBDPath(Path.GetDirectoryName(lbdPath),
                                                              Shader.Find("LSDR/ClassicDiffuse"),
                                                              Shader.Find("LSDR/RevampedDiffuse"));
            Material mat = new Material(DreamSystem.GetShader(alpha: false));

            DreamSystem.TextureSetSystem.RegisterMaterial(mat, texSetOpts);
            SpawnedObject =
                InteractiveObject.Create(lbd, EntityNumber, mat, EntityID, IdleAnimation, PlayIdleAnimation, LuaScript);
            SpawnedObject.transform.position = transform.position;
        }
Exemplo n.º 10
0
        /// <summary>
        /// Create an LBD tilemap GameObject from an LSD level tileset.
        /// </summary>
        /// <param name="lbd">The loaded LBD file.</param>
        /// <returns>A GameObject containing loaded meshes for all tiles in their layout.</returns>
        public GameObject CreateLBDTileMap(LBD lbd, Dictionary <TMDObject, Mesh> cache)
        {
            Profiler.BeginSample("AN LBD!!!");

            GameObject             lbdTilemap    = new GameObject("LBD TileMap");
            List <CombineInstance> meshesCreated = new List <CombineInstance>(); // we're combining meshes into a collision mesh

            // for each tile in the tilemap
            int tileNo = 0;

            foreach (LBDTile tile in lbd.TileLayout)
            {
                int x = tileNo / lbd.Header.TileWidth;
                int y = tileNo % lbd.Header.TileWidth;

                // create an LBD tile if we should draw it
                if (tile.DrawTile)
                {
                    GameObject lbdTile = createLBDTile(tile, lbd.ExtraTiles, x, y, lbd.Tiles, meshesCreated, cache);
                    lbdTile.transform.SetParent(lbdTilemap.transform);
                }

                tileNo++;
            }

            // combine all tiles into mesh for efficient collision
            Mesh combined = new Mesh();

            combined.CombineMeshes(meshesCreated.ToArray(), true);
            MeshCollider mc = lbdTilemap.AddComponent <MeshCollider>();

            mc.sharedMesh = combined;

            // add LBDSlab component for controlling fog/culling
//            LBDSlab slab = lbdTilemap.AddComponent<LBDSlab>();
//            slab.MeshFog = lbdTilemap.GetComponentsInChildren<MeshFog>();
//            slab.CullMesh = lbdTilemap.GetComponentsInChildren<CullMeshOnDistance>();
//            slab.MeshRenderers = lbdTilemap.GetComponentsInChildren<MeshRenderer>();

            Profiler.EndSample();

            return(lbdTilemap);
        }
Exemplo n.º 11
0
        public void CreateObject()
        {
            if (SpawnedObject != null)
            {
                return;
            }

            var lbdPath    = PathUtil.Combine(Application.streamingAssetsPath, LBDFile);
            LBD lbd        = ResourceManager.Load <LBD>(lbdPath, "scene");
            var texSetOpts = TextureSetOptions.GetFromLBDPath(Path.GetDirectoryName(lbdPath),
                                                              Shader.Find("LSDR/ClassicDiffuse"),
                                                              Shader.Find("LSDR/RevampedDiffuse"));
            Material     mat = new Material(Shader.Find("LSDR/RevampedDiffuse"));
            TIXTexture2D tex = ResourceManager.Load <TIXTexture2D>(texSetOpts.APath);

            mat.mainTexture = tex;
            SpawnedObject   =
                InteractiveObject.Create(lbd, EntityNumber, mat, EntityID, IdleAnimation, PlayIdleAnimation, LuaScript);
            SpawnedObject.transform.SetParent(transform);
            SpawnedObject.transform.localPosition = Vector3.zero;
        }
Exemplo n.º 12
0
        private GameObject createLBDTileMap(LBD lbd, Vector3 posOffset, Dictionary <TMDObject, FastMesh> tileCache)
        {
            List <CombineInstance> colliderMeshes = new List <CombineInstance>();

            int tileNo = 0;

            for (int i = 0; i < lbd.TileLayout.Length; i++)
            {
                int     x    = tileNo % lbd.Header.TileWidth;
                int     y    = tileNo / lbd.Header.TileWidth;
                LBDTile tile = lbd.TileLayout[x, y];

                // create an LBD tile if we should draw it
                if (tile.DrawTile)
                {
                    FastMesh mesh   = createTileMesh(tile, lbd.Tiles, tileCache);
                    var      matrix = mesh.AddInstance(new Vector3(x, -tile.TileHeight, y) + posOffset, tileRotation(tile));
                    colliderMeshes.Add(new CombineInstance
                    {
                        mesh         = mesh.Mesh,
                        transform    = matrix,
                        subMeshIndex = 0
                    });
                    if (mesh.Mesh.subMeshCount > 1)
                    {
                        colliderMeshes.Add(new CombineInstance
                        {
                            mesh         = mesh.Mesh,
                            transform    = matrix,
                            subMeshIndex = 1
                        });
                    }

                    // now do extra tiles
                    LBDTile curTile = tile;
                    int     j       = 0;
                    while (curTile.ExtraTileIndex >= 0 && j <= 1)
                    {
                        LBDTile  extraTile     = lbd.ExtraTiles[curTile.ExtraTileIndex];
                        FastMesh extraTileMesh = createTileMesh(extraTile, lbd.Tiles, tileCache);
                        var      extraMatrix   =
                            extraTileMesh.AddInstance(new Vector3(x, -extraTile.TileHeight, y) + posOffset,
                                                      tileRotation(extraTile));
                        colliderMeshes.Add(new CombineInstance
                        {
                            mesh         = extraTileMesh.Mesh,
                            transform    = extraMatrix,
                            subMeshIndex = 0
                        });
                        if (extraTileMesh.Mesh.subMeshCount > 1)
                        {
                            colliderMeshes.Add(new CombineInstance
                            {
                                mesh         = extraTileMesh.Mesh,
                                transform    = extraMatrix,
                                subMeshIndex = 1
                            });
                        }

                        curTile = extraTile;
                        j++;
                    }
                }

                tileNo++;
            }

            return(createLBDCollider(colliderMeshes, posOffset));
        }
Exemplo n.º 13
0
 private void createLBDTileMap(LBD lbd, Dictionary <TMDObject, FastMesh> tileCache)
 {
     createLBDTileMap(lbd, Vector3.zero, tileCache);
 }