void InitRenderer()
        {
            draftModeActive = !applicationIsPlaying && editorDraftMode;
                        #if UNITY_WEBGL
            effectiveUseGeometryShaders = false;
                        #else
            effectiveUseGeometryShaders = useGeometryShaders && !isMobilePlatform && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.Metal;
                        #endif

            // Init materials
            Material matTerrainOpaque, matTerrainCutout, matTerrainWater, matTerrainTransp, matTerrainCutxss, matTerrainOpNoAO;

            Material matTriangleOpaque = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Opaque"));
            Material matTriangleCutout = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Cutout"));

            if (effectiveUseGeometryShaders)
            {
                matTerrainOpaque = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Opaque"));
                matTerrainCutout = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Cutout"));
                if (shadowsOnWater && !draftModeActive)
                {
                    matTerrainWater = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Water"));
                }
                else
                {
                    matTerrainWater = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Water No Shadows"));
                }
                matTerrainCutxss = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Cutout Cross"));
                matTerrainOpNoAO = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Opaque No AO"));
                if (doubleSidedGlass)
                {
                    matTerrainTransp = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Transp Double Sided"));
                }
                else
                {
                    matTerrainTransp = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Geo Transp"));
                }
            }
            else
            {
                matTerrainOpaque = matTriangleOpaque;
                matTerrainCutout = matTriangleCutout;
                if (shadowsOnWater && !draftModeActive)
                {
                    matTerrainWater = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Water"));
                }
                else
                {
                    matTerrainWater = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Water No Shadows"));
                }
                matTerrainCutxss = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Cutout Cross"));
                if (doubleSidedGlass)
                {
                    matTerrainTransp = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Transp Double Sided"));
                }
                else
                {
                    matTerrainTransp = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Triangle Transp"));
                }
                matTerrainOpNoAO = matTerrainOpaque;
            }

            // Init system arrays and structures
            if (materialsDict == null)
            {
                materialsDict = new Dictionary <int, Material[]> ();
            }
            else
            {
                materialsDict.Clear();
            }

            materials = new Material[MAX_MATERIALS_PER_CHUNK];
            materials [INDICES_BUFFER_OPAQUE] = matTerrainOpaque;
            materials [INDICES_BUFFER_CUTOUT] = matTerrainCutout;
            materials [INDICES_BUFFER_CUTXSS] = matTerrainCutxss;
            materials [INDICES_BUFFER_WATER]  = matTerrainWater;
            materials [INDICES_BUFFER_TRANSP] = matTerrainTransp;
            materials [INDICES_BUFFER_OPNOAO] = matTerrainOpNoAO;

            if (materialIndices == null)
            {
                materialIndices = new Dictionary <Material, int> ();
            }
            else
            {
                materialIndices.Clear();
            }
            materialIndices [matTerrainOpaque] = INDICES_BUFFER_OPAQUE;
            materialIndices [matTerrainCutout] = INDICES_BUFFER_CUTOUT;
            materialIndices [matTerrainCutxss] = INDICES_BUFFER_CUTXSS;
            materialIndices [matTerrainWater]  = INDICES_BUFFER_WATER;
            materialIndices [matTerrainTransp] = INDICES_BUFFER_TRANSP;
            materialIndices [matTerrainOpNoAO] = INDICES_BUFFER_OPNOAO;

            // Triangle opaque and cutout are always loaded because dynamic voxels requires them
            if (useGeometryShaders)
            {
                INDICES_BUFFER_OPAQUE_TRIANGLE = 6;
                INDICES_BUFFER_CUTOUT_TRIANGLE = 7;
                lastBufferIndex = 7;
            }
            else
            {
                INDICES_BUFFER_OPAQUE_TRIANGLE = INDICES_BUFFER_OPAQUE;
                INDICES_BUFFER_CUTOUT_TRIANGLE = INDICES_BUFFER_CUTOUT;
                lastBufferIndex = 5;
            }
            materials [INDICES_BUFFER_OPAQUE_TRIANGLE] = matTriangleOpaque;
            materials [INDICES_BUFFER_CUTOUT_TRIANGLE] = matTriangleCutout;


            modelMeshColors = new List <Color32> (128);
            tempVertices    = new List <Vector3> (36);
            tempNormals     = new List <Vector3> (36);
            tempUVs         = new List <Vector4> (36);
            tempIndices     = new int[36];
            tempColors      = new List <Color32> (36);

            InitMeshJobsPool();

            Voxel.Empty.light = noLightValue;
            InitVirtualChunk();

            greedyCollider = new VoxelPlayGreedyMesher();
            greedyNavMesh  = new VoxelPlayGreedyMesher();
            greedyNoAO     = new VoxelPlayGreedyMesher(true);
            greedyCutout   = new VoxelPlayGreedyMesher(true);

            instancingManager = new VoxelPlayInstancingRendererManager(this);

            VoxelPlayLightManager lightManager = currentCamera.GetComponent <VoxelPlayLightManager> ();
            if (lightManager == null)
            {
                currentCamera.gameObject.AddComponent <VoxelPlayLightManager> ();
            }
            else
            {
                lightManager.enabled = true;
            }
            StartGenerationThread();
        }
Example #2
0
        void InitRenderer()
        {
            draftModeActive = !applicationIsPlaying && editorRenderDetail == EditorRenderDetail.Draft;

            // Init materials
            matDynamicOpaque = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Dynamic Opaque"));
            matDynamicCutout = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Dynamic Cutout"));

            Material matTerrainOpaque = Instantiate <Material> (RenderType.Opaque.GetDefaultMaterial(this));
            Material matTerrainCutout = Instantiate <Material> (RenderType.Cutout.GetDefaultMaterial(this));
            Material matTerrainOpNoAO = Instantiate <Material> (RenderType.OpaqueNoAO.GetDefaultMaterial(this));
            Material matTerrainCloud  = Instantiate <Material> (RenderType.Cloud.GetDefaultMaterial(this));
            Material matTerrainWater  = Instantiate <Material> (RenderType.Water.GetDefaultMaterial(this));
            Material matTerrainCutxss = Instantiate <Material> (RenderType.CutoutCross.GetDefaultMaterial(this));
            Material matTerrainTransp = Instantiate <Material> (RenderType.Transp6tex.GetDefaultMaterial(this));
            Material matTerrainOpAnim = Instantiate <Material> (RenderType.OpaqueAnimated.GetDefaultMaterial(this));

            // Init system arrays and structures
            if (materialsDict == null)
            {
                materialsDict = new Dictionary <int, Material []> ();
            }
            else
            {
                materialsDict.Clear();
            }

            // Assign materials to rendering buffers
            renderingMaterials = new RenderingMaterial [MAX_MATERIALS_PER_CHUNK];
            renderingMaterials [INDICES_BUFFER_OPAQUE] = new RenderingMaterial {
                material = matTerrainOpaque, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_CUTOUT] = new RenderingMaterial {
                material = matTerrainCutout, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_CUTXSS] = new RenderingMaterial {
                material = matTerrainCutxss, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_WATER] = new RenderingMaterial {
                material = matTerrainWater, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_TRANSP] = new RenderingMaterial {
                material = matTerrainTransp, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_OPANIM] = new RenderingMaterial {
                material = matTerrainOpAnim, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_OPNOAO] = new RenderingMaterial {
                material = matTerrainOpNoAO, usesTextureArray = true
            };
            renderingMaterials [INDICES_BUFFER_CLOUD] = new RenderingMaterial {
                material = matTerrainCloud, usesTextureArray = true
            };

            if (materialIndices == null)
            {
                materialIndices = new Dictionary <Material, int> ();
            }
            else
            {
                materialIndices.Clear();
            }
            materialIndices [matTerrainOpaque] = INDICES_BUFFER_OPAQUE;
            materialIndices [matTerrainCutout] = INDICES_BUFFER_CUTOUT;
            materialIndices [matTerrainCutxss] = INDICES_BUFFER_CUTXSS;
            materialIndices [matTerrainWater]  = INDICES_BUFFER_WATER;
            materialIndices [matTerrainTransp] = INDICES_BUFFER_TRANSP;
            materialIndices [matTerrainOpAnim] = INDICES_BUFFER_OPANIM;
            materialIndices [matTerrainOpNoAO] = INDICES_BUFFER_OPNOAO;
            materialIndices [matTerrainCloud]  = INDICES_BUFFER_CLOUD;

            // Triangle opaque and cutout are always loaded because dynamic voxels requires them
            lastBufferIndex = 7;

            modelMeshColors   = new List <Color32> (128);
            Voxel.Empty.light = noLightValue;

            InitTempVertices();
            InitSeeThrough();
            InitMeshingThreads();

            if (delayedVoxelCustomRotations == null)
            {
                delayedVoxelCustomRotations = new Dictionary <Vector3, Vector3> ();
            }
            else
            {
                delayedVoxelCustomRotations.Clear();
            }

            if (useComputeBuffers)
            {
                instancedRenderer = new GPUInstancingIndirectRenderer(this);
            }
            else
            {
                instancedRenderer = new GPUInstancingRenderer(this);
            }

            VoxelPlayLightManager lightManager = currentCamera.GetComponent <VoxelPlayLightManager> ();

            if (lightManager == null)
            {
                currentCamera.gameObject.AddComponent <VoxelPlayLightManager> ();
            }
            else
            {
                lightManager.enabled = true;
            }

            if (realisticWater)
            {
                currentCamera.depthTextureMode      |= DepthTextureMode.Depth;
                currentCamera.forceIntoRenderTexture = true;
            }
            //TODO: Creating Meshes
            StartGenerationThreads();
        }