コード例 #1
0
 private void Something(GameObject[] obj)
 {
     if (obj != null)
     {
         int          i      = 0;
         var          rtypes = ResourceType.materialsForCovering;
         MeshFilter   mf;
         MeshRenderer mr;
         while (i < obj.Length & i < rtypes.Length)
         {
             mf = obj[i].GetComponent <MeshFilter>();
             mr = obj[i].GetComponent <MeshRenderer>();
             PoolMaster.SetMaterialByID(ref mf, ref mr, rtypes[i].ID, 255);
             i++;
         }
     }
 }
コード例 #2
0
    protected override void SetModel()
    {
        Transform model         = Instantiate(Resources.Load <GameObject>("Prefs/defaultContainer")).transform;
        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
            );
        model_id            = ContainerModelType.Default;
        model.parent        = transform;
        model.localPosition = Vector3.zero;
        model.localRotation = Quaternion.Euler(Vector3.zero);
        if (PoolMaster.useAdvancedMaterials)
        {
            PoolMaster.ReplaceMaterials(model.gameObject, true);
        }
    }
コード例 #3
0
    override protected void SetModel()
    {
        GameObject model = null;

        if (transform.childCount > 0)
        {
            model = transform.GetChild(0).gameObject;
        }
        Mesh m     = null;
        byte level = (byte)(resourceCount / RESOURCES_PER_LEVEL);

        if (meshes.ContainsKey(level))
        {
            meshes.TryGetValue(level, out m);
        }
        else
        {
            if (resourceCount == 0)
            {
                Annihilate(StructureAnnihilationOrder.SystemDestruction);
                return;
            }
            else
            {
                m = new Mesh();
                float p = Block.QUAD_SIZE * RESOURCE_STICK_RECT_SIZE / (float)PlaneExtension.INNER_RESOLUTION, x = p / 2f;
                float h        = level * 1f / (MAX_STICK_VOLUME / RESOURCES_PER_LEVEL);
                var   vertices = new Vector3[12]
                {
                    new Vector3(-x, 0, x), new Vector3(-x, h, x), new Vector3(x, h, x), new Vector3(x, 0, x),
                    new Vector3(x, 0, -x), new Vector3(x, h, -x),
                    new Vector3(-x, h, -x), new Vector3(-x, 0, -x),
                    new Vector3(-x, h, x), new Vector3(x, h, x), new Vector3(x, h, -x), new Vector3(-x, h, -x)
                };
                var triangles = new int[30]
                {
                    3, 2, 1, 3, 1, 0,
                    4, 5, 2, 4, 2, 3,
                    7, 6, 5, 7, 5, 4,
                    0, 1, 6, 0, 6, 7,
                    11, 8, 9, 11, 9, 10
                };
                x = 1f;
                var uvs = new Vector2[12]
                {
                    new Vector2(x - 0.01f, 0.01f), new Vector2(x - 0.01f, x - 0.01f), new Vector2(0.01f, x - 0.01f), Vector2.one * 0.01f,
                    new Vector2(x - 0.01f, 0.01f), new Vector2(x - 0.01f, x - 0.01f),
                    new Vector2(0.01f, x - 0.01f), Vector2.one * 0.01f,
                    new Vector2(0, x - 0.01f), new Vector2(x - 0.01f, x - 0.01f), new Vector2(x - 0.01f, 0), Vector2.one * 0.01f
                };
                m.vertices  = vertices;
                m.triangles = triangles;
                m.uv        = uvs;
                meshes.Add(level, m);
            }
        }

        MeshFilter mf; MeshRenderer mr;

        if (model != null)
        {
            mf = model.GetComponent <MeshFilter>();
            mr = model.GetComponent <MeshRenderer>();
        }
        else
        {
            model = new GameObject("resourceStick");
            model.transform.parent        = transform;
            model.transform.localRotation = Quaternion.Euler(0, 0, 0);
            model.transform.localPosition = Vector3.zero;
            mf = model.AddComponent <MeshFilter>();
            mr = model.AddComponent <MeshRenderer>();
            mr.receiveShadows       = PoolMaster.shadowCasting;
            mr.shadowCastingMode    = !PoolMaster.useDefaultMaterials ? UnityEngine.Rendering.ShadowCastingMode.On : UnityEngine.Rendering.ShadowCastingMode.Off;
            mr.lightProbeUsage      = UnityEngine.Rendering.LightProbeUsage.Off;
            mr.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
        }

        byte light;

        if (basement != null)
        {
            light = basement.myChunk.lightMap[basement.pos.x, basement.pos.y, basement.pos.z];
        }
        else
        {
            light = 255;
        }

        if (prevModelMesh != null)
        {
            if (prevModelLight == light && prevModelLevel == level && prevModelMaterialID == mainResource.ID)
            {
                mf.sharedMesh     = prevModelMesh;
                mr.sharedMaterial = PoolMaster.GetMaterial(mainResource.ID);
                return;
            }
        }

        mf.sharedMesh       = m;
        prevModelMesh       = PoolMaster.SetMaterialByID(ref mf, ref mr, mainResource.ID, light);
        prevModelLevel      = level;
        prevModelLight      = light;
        prevModelMaterialID = mainResource.ID;
    }
コード例 #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);
            }
        }
    }
コード例 #5
0
    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);
    }