Beispiel #1
0
 public int LOD_existanceCheck(LODRegisterInfo i_regInfo)
 {
     if (registeredLODs.Count == 0)
     {
         return(-1);
     }
     else
     {
         for (int i = 0; i < registeredLODs.Count; i++)
         {
             if (registeredLODs[i].registerInfo == i_regInfo)
             {
                 return(i);
             }
         }
         return(-1);
     }
 }
Beispiel #2
0
    public int activeUsers = 0; // для очистки ненужных текстур

    public LODRegistrationTicket(LODRegisterInfo regInfo, Texture2D i_spriteAtlas, LODPackType i_packType)
    {
        registerInfo = regInfo;
        spriteAtlas  = i_spriteAtlas;
        lodPackType  = i_packType;
        float PIXELS_PER_UNIT = LODSpriteMaker.PIXELS_PER_UNIT;

        switch (lodPackType)
        {
        case LODPackType.Full:
        {
            sprites = new Sprite[32];
            int     index = 0;
            float   p     = spriteAtlas.width / 4;
            Vector3 pivot = Vector2.one * 0.5f;
            for (int i = 0; i < 8; i++)
            {
                sprites[index++] = Sprite.Create(spriteAtlas, new Rect(0, i * p, p, p), pivot, PIXELS_PER_UNIT);
                sprites[index++] = Sprite.Create(spriteAtlas, new Rect(p, i * p, p, p), pivot, PIXELS_PER_UNIT);
                sprites[index++] = Sprite.Create(spriteAtlas, new Rect(2 * p, i * p, p, p), pivot, PIXELS_PER_UNIT);
                sprites[index++] = Sprite.Create(spriteAtlas, new Rect(3 * p, i * p, p, p), pivot, PIXELS_PER_UNIT);
            }
            break;
        }

        case LODPackType.OneSide:
        {
            sprites = new Sprite[4];
            float   p     = spriteAtlas.width / 2;
            Vector3 pivot = Vector2.one * 0.5f;
            sprites[0] = Sprite.Create(spriteAtlas, new Rect(0, 0, p, p), pivot, PIXELS_PER_UNIT);
            sprites[1] = Sprite.Create(spriteAtlas, new Rect(p, 0, p, p), pivot, PIXELS_PER_UNIT);
            sprites[2] = Sprite.Create(spriteAtlas, new Rect(0, p, p, p), pivot, PIXELS_PER_UNIT);
            sprites[3] = Sprite.Create(spriteAtlas, new Rect(p, p, p, p), pivot, PIXELS_PER_UNIT);
            break;
        }

        default:
            sprites    = new Sprite[1];
            sprites[0] = Sprite.Create(spriteAtlas, new Rect(0, 0, spriteAtlas.width, spriteAtlas.height), Vector2.one * 0.5f, PIXELS_PER_UNIT);
            break;
        }
    }
    /// <summary>
    /// Make checks before invoking
    /// </summary>
    public int CreateLODPack(LODPackType i_lpackType, GameObject model, RenderPoint[] renderPoints, int resolution, float shotSize, Color backgroundColor, LODRegisterInfo regInfo)
    {
        backgroundColor.a = 0;
        LODController lcontroller = LODController.GetCurrent();

        backgroundColor.a = 0;
        int savedLayer  = model.layer;
        var layerNumber = 8;

        Renderer[] allObjects = model.transform.GetComponentsInChildren <Renderer>();
        foreach (Renderer r in allObjects)
        {
            r.gameObject.layer = layerNumber;
        }
        if (!PoolMaster.useDefaultMaterials)
        {
            PoolMaster.ReplaceMaterials(allObjects);
        }

        cam.orthographicSize = shotSize;
        cam.backgroundColor  = backgroundColor;

        RenderTexture m_RenderTexture = new RenderTexture(resolution, resolution, 8, RenderTextureFormat.ARGB32);

        cam.transform.parent        = model.transform;
        cam.transform.localRotation = Quaternion.Euler(Vector3.up * 180);

        cam.enabled = true;
        Texture2D atlas;

        switch (i_lpackType)
        {
        case LODPackType.Point:
        {
            cam.transform.localPosition = renderPoints[0].position;
            cam.transform.localRotation = Quaternion.Euler(renderPoints[0].rotation);
            m_RenderTexture.Create();
            cam.targetTexture = m_RenderTexture;
            cam.Render();
            RenderTexture.active = m_RenderTexture;
            atlas = new Texture2D(resolution, resolution);
            atlas.ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
            atlas.Apply();
            break;
        }

        case LODPackType.OneSide:
        {
            Texture2D[] spriteRenders = new Texture2D[4];
            // 0 degrees
            cam.transform.localPosition = renderPoints[0].position;
            cam.transform.localRotation = Quaternion.Euler(renderPoints[0].rotation);
            m_RenderTexture.Create();
            cam.targetTexture = m_RenderTexture;
            cam.Render();
            RenderTexture.active = m_RenderTexture;
            spriteRenders[0]     = new Texture2D(resolution, resolution);
            spriteRenders[0].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
            spriteRenders[0].Apply();
            // 22.5 degrees
            cam.transform.localPosition = renderPoints[1].position;
            cam.transform.localRotation = Quaternion.Euler(renderPoints[1].rotation);
            m_RenderTexture.Create();
            cam.targetTexture = m_RenderTexture;
            cam.Render();
            RenderTexture.active = m_RenderTexture;
            spriteRenders[1]     = new Texture2D(resolution, resolution);
            spriteRenders[1].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
            spriteRenders[1].Apply();
            // 45 degrees
            cam.transform.localPosition = renderPoints[2].position;
            cam.transform.localRotation = Quaternion.Euler(renderPoints[2].rotation);
            m_RenderTexture.Create();
            cam.targetTexture = m_RenderTexture;
            cam.Render();
            RenderTexture.active = m_RenderTexture;
            spriteRenders[2]     = new Texture2D(resolution, resolution);
            spriteRenders[2].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
            spriteRenders[2].Apply();
            // 85 degrees
            cam.transform.localPosition = renderPoints[3].position;
            cam.transform.localRotation = Quaternion.Euler(renderPoints[3].rotation);
            m_RenderTexture.Create();
            cam.targetTexture = m_RenderTexture;
            cam.Render();
            RenderTexture.active = m_RenderTexture;
            spriteRenders[3]     = new Texture2D(resolution, resolution);
            spriteRenders[3].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
            spriteRenders[3].Apply();

            atlas = new Texture2D(2 * resolution, 2 * resolution);
            atlas.PackTextures(spriteRenders, 0, 2 * resolution, false);
            break;
        }

        case LODPackType.Full:
        {
            Texture2D[] spriteRenders = new Texture2D[32];
            int         index         = 0;
            for (int i = 0; i < 8; i++)
            {
                // 0 degrees
                cam.transform.localPosition = renderPoints[index].position;
                cam.transform.localRotation = Quaternion.Euler(renderPoints[index].rotation);
                m_RenderTexture.Create();
                cam.targetTexture = m_RenderTexture;
                cam.Render();
                RenderTexture.active = m_RenderTexture;
                spriteRenders[index] = new Texture2D(resolution, resolution);
                spriteRenders[index].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
                spriteRenders[index].Apply();
                index++;
                // 22.5 degrees
                cam.transform.localPosition = renderPoints[index].position;
                cam.transform.localRotation = Quaternion.Euler(renderPoints[index].rotation);
                m_RenderTexture.Create();
                cam.targetTexture = m_RenderTexture;
                cam.Render();
                RenderTexture.active = m_RenderTexture;
                spriteRenders[index] = new Texture2D(resolution, resolution);
                spriteRenders[index].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
                spriteRenders[index].Apply();
                index++;
                // 45 degrees
                cam.transform.localPosition = renderPoints[index].position;
                cam.transform.localRotation = Quaternion.Euler(renderPoints[index].rotation);
                m_RenderTexture.Create();
                cam.targetTexture = m_RenderTexture;
                cam.Render();
                RenderTexture.active = m_RenderTexture;
                spriteRenders[index] = new Texture2D(resolution, resolution);
                spriteRenders[index].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
                spriteRenders[index].Apply();
                index++;
                // 85 degrees
                cam.transform.localPosition = renderPoints[index].position;
                cam.transform.localRotation = Quaternion.Euler(renderPoints[index].rotation);
                m_RenderTexture.Create();
                cam.targetTexture = m_RenderTexture;
                cam.Render();
                RenderTexture.active = m_RenderTexture;
                spriteRenders[index] = new Texture2D(resolution, resolution);
                spriteRenders[index].ReadPixels(new Rect(0, 0, resolution, resolution), 0, 0);
                spriteRenders[index].Apply();
                index++;
            }
            atlas = new Texture2D(4 * resolution, 8 * resolution);
            atlas.PackTextures(spriteRenders, 0, 8 * resolution, false);
            break;
        }

        default: return(-1);
        }


        cam.enabled          = false;
        cam.transform.parent = null;
        RenderTexture.active = null;

        foreach (Renderer r in allObjects)
        {
            r.gameObject.layer = savedLayer;
        }
        if (!PoolMaster.useDefaultMaterials)
        {
            PoolMaster.ReplaceMaterials(allObjects);
        }
        return(lcontroller.RegisterLOD(new LODRegistrationTicket(regInfo, atlas, i_lpackType)));
    }
Beispiel #4
0
    protected override void SetModel()
    {
        if (transform.childCount == 0)
        {
            GameObject model;

            bool            createSpriteLOD = false;
            LODRegisterInfo regInfo         = new LODRegisterInfo(0, 0, 0);
            float           height          = 0;
            switch (model_id)
            {
            case ContainerModelType.DeadLifestone:
            {
                model = Instantiate(Resources.Load <GameObject>("Structures/LifeStone"));
                Destroy(model.transform.GetChild(0).gameObject);
                Destroy(model.transform.GetChild(1).gameObject);
                MeshRenderer[] mrrs = model.GetComponentsInChildren <MeshRenderer>();
                foreach (MeshRenderer mr in mrrs)
                {
                    mr.sharedMaterial = PoolMaster.GetMaterial(MaterialType.Basic);
                }
                break;
            }

            case ContainerModelType.DeadTreeOfLife:
            {
                model = Instantiate(Resources.Load <GameObject>("Lifeforms/deadTreeOfLife"));
                break;
            }

            case ContainerModelType.DeadOak4:
            {
                model           = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-4_dead"));
                createSpriteLOD = true;
                regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak4, 0);
                height          = 0.211f;
                break;
            }

            case ContainerModelType.DeadOak5:
            {
                model           = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-6_dead"));
                createSpriteLOD = true;
                regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak5, 0);
                height          = 0.211f;
                break;
            }

            case ContainerModelType.DeadOak6:
            {
                model           = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-6_dead"));
                createSpriteLOD = true;
                regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak6, 0);
                height          = 0.211f;
                break;
            }

            case ContainerModelType.Pile:
            {
                model = Instantiate(Resources.Load <GameObject>("Prefs/pilePref"));

                createSpriteLOD = true;
                regInfo         = new LODRegisterInfo((int)ContainerModelType.Pile, 0, mainResource.ID);
                height          = 0.047f;

                Transform meshTransform = model.transform.GetChild(0);
                var       mf            = meshTransform.GetComponent <MeshFilter>();
                var       mr            = meshTransform.GetComponent <MeshRenderer>();
                PoolMaster.SetMaterialByID(
                    ref mf,
                    ref mr,
                    mainResource.ID,
                    255
                    );
                break;
            }

            case ContainerModelType.BerryBush:
            {
                model = Instantiate(Resources.Load <GameObject>("Prefs/berryBush"));
                //if (PoolMaster.shadowCasting) PoolMaster.ReplaceMaterials(model, true);
                break;
            }

            case ContainerModelType.Boulder:
            {
                model = Instantiate(Resources.Load <GameObject>("Prefs/boulderPref"));
                Transform meshTransform = model.transform.GetChild(0);
                var       mf            = meshTransform.GetComponent <MeshFilter>();
                var       mr            = meshTransform.GetComponent <MeshRenderer>();
                PoolMaster.SetMaterialByID(
                    ref mf,
                    ref mr,
                    mainResource.ID,
                    255
                    );

                regInfo         = new LODRegisterInfo((int)ContainerModelType.Boulder, 0, mainResource.ID);
                createSpriteLOD = true;
                height          = 0.047f;
                break;
            }

            default:
            {
                model = Instantiate(Resources.Load <GameObject>("Prefs/defaultContainer"));
                Transform meshTransform = model.transform.GetChild(0);
                var       mf            = meshTransform.GetComponent <MeshFilter>();
                var       mr            = meshTransform.GetComponent <MeshRenderer>();
                PoolMaster.SetMaterialByID(
                    ref mf,
                    ref mr,
                    mainResource.ID,
                    255
                    );
                break;
            }
            }

            if (createSpriteLOD)
            {
                SpriteRenderer sr = new GameObject("lod").AddComponent <SpriteRenderer>();
                sr.transform.parent        = model.transform;
                sr.transform.localPosition = Vector3.up * height;
                sr.sharedMaterial          = !PoolMaster.useDefaultMaterials ? PoolMaster.billboardShadedMaterial : PoolMaster.billboardMaterial;
                if (PoolMaster.shadowCasting)
                {
                    sr.receiveShadows = true;
                }
                LODController currentLC         = LODController.GetCurrent();
                LODPackType   lpackType         = LODPackType.Point;
                int           indexInRegistered = currentLC.LOD_existanceCheck(regInfo);

                if (indexInRegistered == -1)
                {
                    int           resolution      = 8;
                    float         size            = 0.05f;
                    Color         backgroundColor = Color.gray;
                    RenderPoint[] renderpoints    = new RenderPoint[] { };

                    switch (model_id)
                    {
                    case ContainerModelType.Pile:
                    {
                        renderpoints = new RenderPoint[] { new RenderPoint(new Vector3(0, 0.084f, -0.063f), new Vector3(45, 0, 0)) };
                        break;
                    }

                    case ContainerModelType.Boulder:
                    {
                        renderpoints = new RenderPoint[] { new RenderPoint(new Vector3(0, 0.084f, -0.063f), new Vector3(45, 0, 0)) };
                        break;
                    }

                    case ContainerModelType.DeadOak4:
                    {
                        renderpoints = new RenderPoint[] {
                            new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                            new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                        };
                        size       = 0.2f;
                        resolution = 32;
                        lpackType  = LODPackType.OneSide;
                        break;
                    }

                    case ContainerModelType.DeadOak5:
                    {
                        renderpoints = new RenderPoint[] {
                            new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                            new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                        };
                        size       = 0.25f;
                        resolution = 32;
                        lpackType  = LODPackType.OneSide;
                        break;
                    }

                    case ContainerModelType.DeadOak6:
                    {
                        renderpoints = new RenderPoint[] {
                            new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                            new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                            new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                        };
                        size       = 0.4f;
                        resolution = 64;
                        lpackType  = LODPackType.OneSide;
                        break;
                    }
                    }

                    indexInRegistered = LODSpriteMaker.current.CreateLODPack(lpackType, model, renderpoints, resolution, size, backgroundColor, regInfo);
                }
                model.transform.parent        = transform;
                model.transform.localPosition = Vector3.zero;
                model.transform.localRotation = Quaternion.Euler(Vector3.zero);
                lodComponent = currentLC.SetInControl(basement, model.transform.GetChild(0).gameObject, sr, indexInRegistered);
            }
            else
            {
                model.transform.parent        = transform;
                model.transform.localPosition = Vector3.zero;
                model.transform.localRotation = Quaternion.Euler(Vector3.zero);
            }
        }
    }
    public static HarvestableResource ConstructContainer(ContainerModelType i_modelType, ResourceType i_rtype, float i_count)
    {
        HarvestableResource hr = new GameObject().AddComponent <HarvestableResource>();

        hr.ID = CONTAINER_ID;
        hr.PrepareStructure();
        hr.mainResource  = i_rtype;
        hr.resourceCount = i_count;
        GameObject model;

        bool            createSpriteLOD = false;
        LODRegisterInfo regInfo         = new LODRegisterInfo(0, 0, 0);
        float           height          = 0;

        hr.model_id = i_modelType;
        switch (hr.model_id)
        {
        case ContainerModelType.DeadLifestone:
        {
            hr.gameObject.name = "dead Lifestone";
            model = Instantiate(Resources.Load <GameObject>("Structures/LifeStone"));
            Destroy(model.transform.GetChild(0).gameObject);
            Destroy(model.transform.GetChild(1).gameObject);
            MeshRenderer[] mrrs = model.GetComponentsInChildren <MeshRenderer>();
            foreach (MeshRenderer mr in mrrs)
            {
                mr.sharedMaterial = PoolMaster.GetMaterial(MaterialType.Basic);
            }
            byte c = (byte)(PlaneExtension.INNER_RESOLUTION / 4);
            hr.surfaceRect = new SurfaceRect(c, c, (byte)(c + c));
            hr.maxHp       = LifeSource.MAX_HP * 0.9f;
            break;
        }

        case ContainerModelType.DeadTreeOfLife:
        {
            hr.gameObject.name = "dead Tree of Life";
            model = Instantiate(Resources.Load <GameObject>("Lifeforms/deadTreeOfLife"));
            byte c = (byte)(PlaneExtension.INNER_RESOLUTION / 4);
            hr.surfaceRect = new SurfaceRect(c, c, (byte)(c + c));
            hr.maxHp       = LifeSource.MAX_HP * 0.9f;
            break;
        }

        case ContainerModelType.DeadOak4:
            hr.gameObject.name = "dead oak 4";
            model          = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-4_dead"));
            hr.surfaceRect = SurfaceRect.one;
            hr.maxHp       = 50;

            createSpriteLOD = true;
            regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak4, 0);
            height          = 0.211f;
            break;

        case ContainerModelType.DeadOak5:
            hr.gameObject.name = "dead oak 5";
            model          = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-6_dead"));
            hr.surfaceRect = SurfaceRect.one;
            hr.maxHp       = 100;

            createSpriteLOD = true;
            regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak5, 0);
            height          = 0.211f;
            break;

        case ContainerModelType.DeadOak6:
            hr.gameObject.name = "dead oak 6";
            model          = Instantiate(Resources.Load <GameObject>("Lifeforms/oak-6_dead"));
            hr.surfaceRect = SurfaceRect.one;
            hr.maxHp       = 200;

            createSpriteLOD = true;
            regInfo         = new LODRegisterInfo(LODController.CONTAINER_MODEL_ID, (int)ContainerModelType.DeadOak6, 0);
            height          = 0.211f;
            break;

        case ContainerModelType.Pile:
        {
            hr.gameObject.name = "pile";
            model = Instantiate(Resources.Load <GameObject>("Prefs/pilePref"));

            createSpriteLOD = true;
            regInfo         = new LODRegisterInfo((int)ContainerModelType.Pile, 0, hr.mainResource.ID);
            height          = 0.047f;

            Transform meshTransform = model.transform.GetChild(0);
            var       mf            = meshTransform.GetComponent <MeshFilter>();
            var       mr            = meshTransform.GetComponent <MeshRenderer>();
            PoolMaster.SetMaterialByID(
                ref mf,
                ref mr,
                i_rtype.ID,
                255
                );
            hr.maxHp       = 30;
            hr.surfaceRect = SurfaceRect.one;
            break;
        }

        case ContainerModelType.BerryBush:
        {
            hr.gameObject.name = "berry bush";
            model = Instantiate(Resources.Load <GameObject>("Prefs/berryBush"));
            //if (PoolMaster.shadowCasting) PoolMaster.ReplaceMaterials(model, true);
            hr.maxHp       = 10;
            hr.surfaceRect = SurfaceRect.one;
            break;
        }

        case ContainerModelType.Boulder:
        {
            hr.gameObject.name = "boulder";
            model = Instantiate(Resources.Load <GameObject>("Prefs/boulderPref"));
            Transform meshTransform = model.transform.GetChild(0);
            var       mf            = meshTransform.GetComponent <MeshFilter>();
            var       mr            = meshTransform.GetComponent <MeshRenderer>();
            PoolMaster.SetMaterialByID(
                ref mf,
                ref mr,
                i_rtype.ID,
                255
                );

            regInfo         = new LODRegisterInfo((int)ContainerModelType.Boulder, 0, hr.mainResource.ID);
            createSpriteLOD = true;
            height          = 0.047f;

            hr.maxHp       = 50;
            hr.surfaceRect = SurfaceRect.one;
            break;
        }

        default:
        {
            hr.gameObject.name = "default container";
            model = Instantiate(Resources.Load <GameObject>("Prefs/defaultContainer"));
            Transform meshTransform = model.transform.GetChild(0);
            var       mf            = meshTransform.GetComponent <MeshFilter>();
            var       mr            = meshTransform.GetComponent <MeshRenderer>();
            PoolMaster.SetMaterialByID(
                ref mf,
                ref mr,
                i_rtype.ID,
                255
                );

            hr.model_id = ContainerModelType.Default;

            hr.maxHp       = 10;
            hr.surfaceRect = SurfaceRect.one;
            break;
        }
        }
        hr.hp = hr.maxHp;

        if (createSpriteLOD)
        {
            SpriteRenderer sr = new GameObject("lod").AddComponent <SpriteRenderer>();
            sr.transform.parent        = model.transform;
            sr.transform.localPosition = Vector3.up * height;
            sr.sharedMaterial          = PoolMaster.useAdvancedMaterials ? PoolMaster.billboardShadedMaterial : PoolMaster.billboardMaterial;;
            if (PoolMaster.shadowCasting)
            {
                sr.receiveShadows = true;
            }
            LODController currentLC = LODController.GetCurrent();
            LODPackType   lpackType = LODPackType.Point;
            int           indexInRegistered = currentLC.LOD_existanceCheck(regInfo);
            float         lodDistance = 6, visibilityDistance = 15;

            if (indexInRegistered == -1)
            {
                int           resolution      = 8;
                float         size            = 0.05f;
                Color         backgroundColor = Color.gray;
                RenderPoint[] renderpoints    = new RenderPoint[] { };

                switch (hr.model_id)
                {
                case ContainerModelType.Pile:
                {
                    renderpoints = new RenderPoint[] { new RenderPoint(new Vector3(0, 0.084f, -0.063f), new Vector3(45, 0, 0)) };
                    break;
                }

                case ContainerModelType.Boulder:
                {
                    renderpoints = new RenderPoint[] { new RenderPoint(new Vector3(0, 0.084f, -0.063f), new Vector3(45, 0, 0)) };
                    break;
                }

                case ContainerModelType.DeadOak4:
                {
                    renderpoints = new RenderPoint[] {
                        new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                        new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                    };
                    size               = 0.2f;
                    resolution         = 32;
                    lpackType          = LODPackType.OneSide;
                    lodDistance        = 15;
                    visibilityDistance = 24;
                    break;
                }

                case ContainerModelType.DeadOak5:
                {
                    renderpoints = new RenderPoint[] {
                        new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                        new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                    };
                    size               = 0.25f;
                    resolution         = 32;
                    lpackType          = LODPackType.OneSide;
                    lodDistance        = 18;
                    visibilityDistance = 28;
                    break;
                }

                case ContainerModelType.DeadOak6:
                {
                    renderpoints = new RenderPoint[] {
                        new RenderPoint(new Vector3(0, 0.222f, -0.48f), Vector3.zero),
                        new RenderPoint(new Vector3(0, 0.479f, -0.434f), new Vector3(30, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.458f, -0.232f), new Vector3(45, 0, 0)),
                        new RenderPoint(new Vector3(0, 0.551f, -0.074f), new Vector3(75, 0, 0))
                    };
                    size               = 0.4f;
                    lodDistance        = 21;
                    visibilityDistance = 32;
                    resolution         = 64;
                    lpackType          = LODPackType.OneSide;
                    break;
                }
                }

                indexInRegistered = LODSpriteMaker.current.CreateLODPack(lpackType, model, renderpoints, resolution, size, backgroundColor, regInfo);
            }
            model.transform.parent        = hr.transform;
            model.transform.localPosition = Vector3.zero;
            model.transform.localRotation = Quaternion.Euler(Vector3.zero);
            LODController.GetCurrent().TakeCare(model.transform, indexInRegistered, lodDistance, visibilityDistance);
        }
        else
        {
            model.transform.parent        = hr.transform;
            model.transform.localPosition = Vector3.zero;
            model.transform.localRotation = Quaternion.Euler(Vector3.zero);
        }
        return(hr);
    }