private IEnumerator RemoveInstancesAtRuntime()
        {
            for (int i = 0; i < instanceCount; i++)
            {
                if (!instancesList[instancesList.Count - 1].prefabPrototype.addRuntimeHandlerScript)
                {
                    GPUInstancerAPI.RemovePrefabInstance(prefabManager, instancesList[instancesList.Count - 1]);
                }
                Destroy(instancesList[instancesList.Count - 1].gameObject);
                instancesList.RemoveAt(instancesList.Count - 1);
                if (!addRemoveInstantlyToggle.isOn)
                {
                    yield return(new WaitForSeconds(0.001f));
                }
            }

            EnableButton("AddInstancesButton");
            if (extraInstancesList.Count == 0)
            {
                EnableButton("AddExtraInstancesButton");
            }
            else
            {
                EnableButton("RemoveExtraInstancesButton");
            }
        }
        void Start()
        {
            goList = new List <GPUInstancerPrefab>();

            // Define the buffer to the Prefab Manager.
            if (prefabManager != null && prefabManager.isActiveAndEnabled)
            {
                GPUInstancerAPI.DefinePrototypeVariationBuffer <Vector4>(prefabManager, prefab.prefabPrototype, bufferName);
            }

            // Generate instances inside a radius.
            for (int i = 0; i < instances; i++)
            {
                GPUInstancerPrefab prefabInstance = Instantiate(prefab);
                prefabInstance.transform.localPosition = Random.insideUnitSphere * 20;
                prefabInstance.transform.SetParent(transform);
                goList.Add(prefabInstance);

                // Register the variation buffer for this instance.
                prefabInstance.AddVariation(bufferName, (Vector4)Random.ColorHSV());
            }

            // Register the generated instances to the manager and initialize the manager.
            if (prefabManager != null && prefabManager.isActiveAndEnabled)
            {
                GPUInstancerAPI.RegisterPrefabInstanceList(prefabManager, goList);
                GPUInstancerAPI.InitializeGPUInstancer(prefabManager);
            }
        }
        private IEnumerator AddInstancesAtRuntime()
        {
            for (int i = 0; i < instanceCount; i++)
            {
                GPUInstancerPrefab prefabInstance = Instantiate(prefab);
                prefabInstance.transform.localPosition = Random.insideUnitSphere * 10;
                prefabInstance.transform.SetParent(parentTransform);
                if (!prefabInstance.prefabPrototype.addRuntimeHandlerScript)
                {
                    GPUInstancerAPI.AddPrefabInstance(prefabManager, prefabInstance);
                }
                instancesList.Add(prefabInstance);
                if (!addRemoveInstantlyToggle.isOn)
                {
                    yield return(new WaitForSeconds(0.001f));
                }
            }

            EnableButton("RemoveInstancesButton");
            if (extraInstancesList.Count == 0)
            {
                EnableButton("AddExtraInstancesButton");
            }
            else
            {
                EnableButton("RemoveExtraInstancesButton");
            }
        }
 private void Update()
 {
     if (prefabManager != null && prefabManager.isActiveAndEnabled)
     {
         Rigidbody rb;
         for (int i = 0; i < _enteredInstances.Count; i++)
         {
             if (!IsInsideCollider(_enteredInstances[i]))
             {
                 rb = _enteredInstances[i].GetComponent <Rigidbody>();
                 if (rb != null && !rb.IsSleeping())
                 {
                     continue;
                 }
                 GPUInstancerAPI.EnableInstancingForInstance(prefabManager, _enteredInstances[i]);
                 _enteredInstances.Remove(_enteredInstances[i]);
                 i--;
             }
             else if (_enteredInstances[i].state != PrefabInstancingState.Disabled)
             {
                 prefabManager.DisableIntancingForInstance(_enteredInstances[i]);
             }
         }
     }
 }
Exemple #5
0
        private void Awake()
        {
            // Setup UI
            _uiCanvas = GameObject.Find("Canvas");
            _spaceShipControlsText       = GameObject.Find("SpaceShipControlsPanel");
            _grassMowerControlsText      = GameObject.Find("GrassMowerControlsPanel");
            _loadingTerrainDetailsText   = GameObject.Find("LoadingInfoPanel");
            _currentQualityModeText      = GameObject.Find("CurrentQualityModeInfoText").GetComponent <Text>();
            _currentQualityModeText.text = "Current Quality Mode: " + _currentQualityMode + " Quality";

            // Setup space ship
            _spaceShip             = FindObjectOfType <SpaceshipController>().transform;
            _spaceShipThrusterGlow = _spaceShip.GetChild(0).GetChild(0).GetComponent <ParticleSystem>();

            // Setup grass mower
            _grassMower = FindObjectOfType <GrassMowerController>().transform;

            // Setup camera
            SetCameraMode(CameraModes.FPMode);

            SetPrototypesByQuality(_currentQualityMode);

            // Setup loading bar
            GPUInstancerAPI.StartListeningGPUIEvent(GPUInstancerEventType.DetailInitializationFinished, DisableLoadingTerrainDetailsText);
        }
        private void Start()
        {
            // Create a GameObject to create a prototype from
            prototypeGameObject = GameObject.CreatePrimitive(PrimitiveType.Quad);

            // Set material of the GameObject
            SetMaterial();

            // Create a list to keep track of instances
            instanceList = new List <GameObject>();

            // Add the original to the instanceList
            instanceList.Add(prototypeGameObject);

            // Your instantiation logic. Uses the prototype GameObject to identify the newly generated prototype.
            // This example just instantiates objects at random positions inside a sphere with radius of 20;
            // Replace this with how you want to generate your instances.
            for (int i = 0; i < 1000; i++)
            {
                instanceList.Add(Instantiate(prototypeGameObject, UnityEngine.Random.insideUnitSphere * 20, Quaternion.identity));
            }

            // Define the prototype
            prototype = GPUInstancerAPI.DefineGameObjectAsPrefabPrototypeAtRuntime(prefabManager, prototypeGameObject);

            // Make changes in the prototype settings
            prototype.enableRuntimeModifications = true;
            prototype.autoUpdateTransformData    = true;

            // Add the prototype instances
            GPUInstancerAPI.AddInstancesToPrefabPrototypeAtRuntime(prefabManager, prototype, instanceList);

            // Start Coroutine to change instances over time
            StartCoroutine(AddRemoveAtRuntime());
        }
Exemple #7
0
        // Use this for initialization
        private void Awake()
        {
            // min buffersize check
            if (bufferSize < 1000)
                bufferSize = 1000;
            // initialize the array with the max size
            _matrix4x4Array = new Matrix4x4[bufferSize];
            // change the data of the array
            AddMatrix4x4ToArray(1000);

            // initialize the buffers with array
            GPUInstancerAPI.InitializeWithMatrix4x4Array(prefabManager, prefab.prefabPrototype, _matrix4x4Array);
            GPUInstancerAPI.SetInstanceCount(prefabManager, prefab.prefabPrototype, sphereCount);

            // Color variatons
            variationData = new Vector4[bufferSize];
            for (int i = 0; i < bufferSize; i++)
                variationData[i] = Random.ColorHSV();
            GPUInstancerAPI.DefineAndAddVariationFromArray(prefabManager, prefab.prefabPrototype, bufferName, variationData);

            // UI
            CheckButtonsAvailablity();
            // Start Update Positions coroutine
            StartCoroutine(UpdatePositions());

            StartCoroutine(UpdateScale());

            StartCoroutine(UpdateColors());
        }
Exemple #8
0
 // Update 100 random sphere positions
 private IEnumerator UpdateScale()
 {
     while (true)
     {
         if (sphereCount > 100 && scaleUpdateFrequency > 0)
         {
             Matrix4x4 instance;
             Vector3 position;
             Quaternion rotation;
             Vector3 newScale;
             // update 100 positions starting from random index
             int randomIndex = Random.Range(0, sphereCount - 100);
             for (int i = randomIndex; i < randomIndex + 100; i++)
             {
                 instance = _matrix4x4Array[i];
                 position = instance.GetColumn(3);
                 rotation = Quaternion.LookRotation(instance.GetColumn(2), instance.GetColumn(1));
                 newScale = Vector3.one * Random.Range(0.5f, 1.5f);
                 _matrix4x4Array[i] = Matrix4x4.TRS(position, rotation, newScale);
             }
             // set updated transform data
             GPUInstancerAPI.UpdateVisibilityBufferWithMatrix4x4Array(prefabManager, prefab.prefabPrototype, _matrix4x4Array, randomIndex, randomIndex, 100);
         }
         yield return new WaitForSeconds(1 - scaleUpdateFrequency + 0.01f);
     }
 }
        private IEnumerator AddExtraInstancesAtRuntime()
        {
            // Extra instance count that can be added at runtime is limited by the "Extra buffer size" property defined for this prefab prototype in the manager.
            for (int i = 0; i < prefab.prefabPrototype.extraBufferSize; i++)
            {
                GPUInstancerPrefab prefabInstance = Instantiate(prefab);
                prefabInstance.transform.localPosition = Random.insideUnitSphere * 5;

                // Move the extra spheres to the outer sphere
                prefabInstance.transform.localPosition = prefabInstance.transform.localPosition.normalized * (prefabInstance.transform.localPosition.magnitude + 10f);

                prefabInstance.transform.SetParent(parentTransform);
                if (!prefabInstance.prefabPrototype.addRuntimeHandlerScript)
                {
                    GPUInstancerAPI.AddPrefabInstance(prefabManager, prefabInstance);
                }
                extraInstancesList.Add(prefabInstance);
                if (!addRemoveInstantlyToggle.isOn)
                {
                    yield return(new WaitForSeconds(0.001f));
                }
            }

            EnableButton("RemoveExtraInstancesButton");
            if (instancesList.Count == 0)
            {
                EnableButton("AddInstancesButton");
            }
            else
            {
                EnableButton("RemoveInstancesButton");
            }
        }
 public void ReInitializeManagers()
 {
     for (int i = 0; i < terrainCounter; i++)
     {
         GPUInstancerDetailManager detailManager = terrainArray[i].GetComponent <GPUInstancerDetailManager>();
         GPUInstancerAPI.InitializeGPUInstancer(detailManager);
     }
 }
Exemple #11
0
 private void Start()
 {
     if (prefabManager != null && prefabManager.gameObject.activeSelf && prefabManager.enabled)
     {
         GPUInstancerAPI.RegisterPrefabInstanceList(prefabManager, asteroidInstances);
         GPUInstancerAPI.InitializeGPUInstancer(prefabManager);
     }
 }
Exemple #12
0
 public void AddSpheres()
 {
     int previousSphereCount = sphereCount;
     AddMatrix4x4ToArray(1000);
     // UI
     CheckButtonsAvailablity();
     // set updated transform data
     GPUInstancerAPI.UpdateVisibilityBufferWithMatrix4x4Array(prefabManager, prefab.prefabPrototype, _matrix4x4Array,
         previousSphereCount, previousSphereCount, 1000);
     GPUInstancerAPI.SetInstanceCount(prefabManager, prefab.prefabPrototype, sphereCount);
 }
 private void Update()
 {
     if (_camera.isActiveAndEnabled && !_isCameraSet)
     {
         GPUInstancerAPI.SetCamera(_camera);
         _isCameraSet = true;
     }
     else if (!_camera.isActiveAndEnabled && _isCameraSet)
     {
         _isCameraSet = false;
     }
 }
Exemple #14
0
        private void SetCameraMode(CameraModes cameraMode)
        {
            if (!fpController || !spaceshipCamera || !grassMowerCamera)
            {
                Debug.Log("Not all cameras are set. Please assign the relevant cameras from the inspector");
                return;
            }

            fpController.SetActive(false);
            spaceshipCamera.SetActive(false);
            grassMowerCamera.SetActive(false);

            _spaceShip.GetComponent <SpaceshipController>().enabled = false;
            _spaceShipThrusterGlow.gameObject.SetActive(false);
            _spaceShipControlsText.gameObject.SetActive(false);

            _grassMower.GetComponent <GrassMowerController>().enabled        = false;
            _grassMower.GetComponent <GPUInstancerInstanceRemover>().enabled = false;
            _grassMowerControlsText.gameObject.SetActive(false);

            switch (cameraMode)
            {
            case CameraModes.FPMode:
                fpController.SetActive(true);
                _activeCameraGO = fpController;
                break;

            case CameraModes.SpaceshipMode:
                spaceshipCamera.SetActive(true);
                _spaceShip.GetComponent <SpaceshipController>().enabled = true;
                _spaceShipThrusterGlow.gameObject.SetActive(true);
                _spaceShipControlsText.gameObject.SetActive(true);
                _activeCameraGO = spaceshipCamera;
                break;

            case CameraModes.MowerMode:
                grassMowerCamera.SetActive(true);
                _grassMower.GetComponent <GrassMowerController>().enabled        = true;
                _grassMower.GetComponent <GPUInstancerInstanceRemover>().enabled = true;
                _grassMowerControlsText.gameObject.SetActive(true);
                _activeCameraGO = grassMowerCamera;
                break;
            }

            _currentCameraMode = cameraMode;

            // Notify GPU Instancer of the camera change:
            GPUInstancerAPI.SetCamera(_activeCameraGO.GetComponentInChildren <Camera>());
        }
Exemple #15
0
 void Update()
 {
     if (transform.hasChanged && transform.position != _previousPosition)
     {
         foreach (GPUInstancerManager manager in gPUIManagers)
         {
             if (manager != null)
             {
                 GPUInstancerAPI.SetGlobalPositionOffset(manager, transform.position - _previousPosition);
             }
         }
         _previousPosition    = transform.position;
         transform.hasChanged = false;
     }
 }
Exemple #16
0
 // Update 100 random sphere positions
 private IEnumerator UpdateColors()
 {
     while (true)
     {
         if (sphereCount > 100 && colorUpdateFrequency > 0)
         {
             // update 100 positions starting from random index
             int randomIndex = Random.Range(0, sphereCount - 100);
             for (int i = randomIndex; i < randomIndex + 100; i++)
                 variationData[i] = Random.ColorHSV();
             // set updated transform data
             GPUInstancerAPI.UpdateVariationFromArray(prefabManager, prefab.prefabPrototype, bufferName, variationData, randomIndex, randomIndex, 100);
         }
         yield return new WaitForSeconds(1 - colorUpdateFrequency + 0.01f);
     }
 }
Exemple #17
0
        private void Update()
        {
            if (Input.GetKeyUp(KeyCode.C))
            {
                SwitchCameraMode();
            }

            if (Input.GetKeyUp(KeyCode.U))
            {
                _uiCanvas.gameObject.SetActive(!_uiCanvas.gameObject.activeSelf);
            }

            if (Input.GetKeyUp(KeyCode.F1))
            {
                if (detailManager.gameObject.activeSelf && persistRemoval)
                {
                    detailMapData = GPUInstancerAPI.GetDetailMapData(detailManager);
                }
                detailManager.gameObject.SetActive(!detailManager.gameObject.activeSelf);
                if (detailManager.gameObject.activeSelf)
                {
                    if (persistRemoval && detailMapData != null)
                    {
                        GPUInstancerAPI.SetDetailMapData(detailManager, detailMapData);
                    }
                    _loadingTerrainDetailsText.SetActive(true);
                    GPUInstancerAPI.SetCamera(_activeCameraGO.GetComponentInChildren <Camera>());
                    GPUInstancerAPI.StartListeningGPUIEvent(GPUInstancerEventType.DetailInitializationFinished, DisableLoadingTerrainDetailsText);
                }
                SetQualityMode(_currentQualityMode);
            }

            if (Input.GetKeyUp(KeyCode.F2))
            {
                SetQualityMode(QualityMode.Low);
            }

            if (Input.GetKeyUp(KeyCode.F3))
            {
                SetQualityMode(QualityMode.Mid);
            }

            if (Input.GetKeyUp(KeyCode.F4))
            {
                SetQualityMode(QualityMode.High);
            }
        }
        private void UpdateManagers()
        {
            for (int i = 0; i < terrainCounter; i++)
            {
                GPUInstancerDetailManager detailManager = terrainArray[i].GetComponent <GPUInstancerDetailManager>();

                detailManager.terrainSettings.windVector = _windVector;

                for (int j = 0; j < detailManager.prototypeList.Count; j++)
                {
                    GPUInstancerDetailPrototype detailPrototype = (GPUInstancerDetailPrototype)detailManager.prototypeList[j];

                    // noise settings:
                    detailPrototype.detailHealthyColor = _healthyColor;
                    detailPrototype.detailDryColor     = _dryColor;
                    detailPrototype.noiseSpread        = _noiseSpread;
                    detailPrototype.ambientOcclusion   = _ambientOcclusion;
                    detailPrototype.gradientPower      = _gradientPower;

                    // wind settings:
                    detailPrototype.windIdleSway      = _windIdleSway;
                    detailPrototype.windWavesOn       = _windWavesOn;
                    detailPrototype.windWaveTint      = _windWaveTint;
                    detailPrototype.windWaveSize      = _windWaveSize;
                    detailPrototype.windWaveSway      = _windWaveSway;
                    detailPrototype.windWaveTintColor = _windWaveTintColor;

                    // mesh settings:
                    detailPrototype.isBillboard       = _useCrossQuads ? false : _isBillboard;
                    detailPrototype.useCrossQuads     = _useCrossQuads;
                    detailPrototype.quadCount         = _crossQuadCount;
                    detailPrototype.billboardDistance = _crossQuadBillboardDistance;
                    detailPrototype.detailScale       = _scale;

                    // GPU Instancer settings
                    detailPrototype.isShadowCasting  = _isShadowCasting;
                    detailPrototype.isFrustumCulling = _isFrustumCulling;
                    detailPrototype.frustumOffset    = _frustumOffset;
                    detailPrototype.maxDistance      = _maxDistance;
                }

                GPUInstancerAPI.UpdateDetailInstances(detailManager, true);
            }
        }
Exemple #19
0
 // Update 100 random sphere positions
 private IEnumerator UpdatePositions()
 {
     while (true)
     {
         if(sphereCount > 100 && positionUpdateFrequency > 0)
         {
             Vector3 newPosition;
             // update 100 positions starting from random index
             int randomIndex = Random.Range(0, sphereCount - 100);
             for (int i = randomIndex; i < randomIndex + 100; i++)
             {
                 newPosition = Random.insideUnitSphere * 20;
                 _matrix4x4Array[i].SetColumn(3, new Vector4(newPosition.x, newPosition.y, newPosition.z, _matrix4x4Array[i][3, 3]));
             }
             // set updated transform data
             GPUInstancerAPI.UpdateVisibilityBufferWithMatrix4x4Array(prefabManager, prefab.prefabPrototype, _matrix4x4Array, randomIndex, randomIndex, 100);
         }
         yield return new WaitForSeconds(1 - positionUpdateFrequency + 0.01f);
     }
 }
        IEnumerator AddRemoveAtRuntime()
        {
            while (true)
            {
                // Loop through primitives
                foreach (PrimitiveType primitiveType in Enum.GetValues(typeof(PrimitiveType)))
                {
                    yield return(new WaitForSeconds(3));

                    // Remove runtime generated prototype definition
                    GPUInstancerAPI.RemovePrototypeAtRuntime(prefabManager, prototype);
                    // Clear the instances
                    ClearInstances();

                    yield return(new WaitForSeconds(1));

                    // Create a GameObject to create a prototype from
                    prototypeGameObject = GameObject.CreatePrimitive(primitiveType);

                    // Set material of the GameObject
                    SetMaterial();

                    // Add the original to the instanceList
                    instanceList.Add(prototypeGameObject);

                    // Define the prototype
                    prototype = GPUInstancerAPI.DefineGameObjectAsPrefabPrototypeAtRuntime(prefabManager, prototypeGameObject);

                    // Create 1000 new instances
                    for (int i = 0; i < 1000; i++)
                    {
                        instanceList.Add(Instantiate(prototypeGameObject, UnityEngine.Random.insideUnitSphere * 20, Quaternion.identity));
                    }

                    // Add instances to manager
                    GPUInstancerAPI.AddInstancesToPrefabPrototypeAtRuntime(prefabManager, prototype, instanceList);

                    yield return(new WaitForSeconds(1));
                }
            }
        }
        private void AddInstancer(Terrain terrain)
        {
            GPUInstancerDetailManager detailManager = terrain.gameObject.AddComponent <GPUInstancerDetailManager>();

            GPUInstancerAPI.SetupManagerWithTerrain(detailManager, terrain);

            detailManager.terrainSettings.windVector = _windVector;

            // Can change prototype properties here
            if (detailManager.prototypeList.Count > 0)
            {
                GPUInstancerDetailPrototype detailPrototype = (GPUInstancerDetailPrototype)detailManager.prototypeList[0];

                detailPrototype.detailHealthyColor = _healthyColor;
                detailPrototype.detailDryColor     = _dryColor;
                detailPrototype.noiseSpread        = _noiseSpread;
                detailPrototype.ambientOcclusion   = _ambientOcclusion;
                detailPrototype.gradientPower      = _gradientPower;

                detailPrototype.windIdleSway      = _windIdleSway;
                detailPrototype.windWavesOn       = _windWavesOn;
                detailPrototype.windWaveTint      = _windWaveTint;
                detailPrototype.windWaveSize      = _windWaveSize;
                detailPrototype.windWaveSway      = _windWaveSway;
                detailPrototype.windWaveTintColor = _windWaveTintColor;

                detailPrototype.isBillboard       = _isBillboard;
                detailPrototype.useCrossQuads     = _useCrossQuads;
                detailPrototype.quadCount         = _crossQuadCount;
                detailPrototype.billboardDistance = _crossQuadBillboardDistance;
                detailPrototype.detailScale       = _scale;

                detailPrototype.isShadowCasting  = _isShadowCasting;
                detailPrototype.isFrustumCulling = _isFrustumCulling;
                detailPrototype.frustumOffset    = _frustumOffset;
                detailPrototype.maxDistance      = _maxDistance;
            }

            GPUInstancerAPI.InitializeGPUInstancer(detailManager);
        }
Exemple #22
0
        private void SetQualityMode(QualityMode qualityMode)
        {
            if (!detailManager.gameObject.activeSelf)
            {
                _currentQualityModeText.text = "Current Quality Mode: GPU Instancer disabled (Unity terrain)";
            }
            else
            {
                _currentQualityModeText.text = "Current Quality Mode: " + qualityMode + " Quality";

                if (_currentQualityMode == qualityMode)
                {
                    return;
                }

                _currentQualityMode = qualityMode;

                SetPrototypesByQuality(qualityMode);


                GPUInstancerAPI.UpdateDetailInstances(detailManager, true);
            }
        }
Exemple #23
0
 private void Start()
 {
     foreach (GPUInstancerManager manager in GPUInstancerManager.activeManagerList)
     {
         if ((!removeFromDetailManagers && manager is GPUInstancerDetailManager) ||
             (!removeFromTreeManagers && manager is GPUInstancerTreeManager) ||
             (!removeFromPrefabManagers && manager is GPUInstancerPrefabManager))
         {
             continue;
         }
         //GPUInstancerAPI.InitializeGPUInstancer(manager, false);
         foreach (Collider collider in selectedColliders)
         {
             if (useBounds)
             {
                 GPUInstancerAPI.RemoveInstancesInsideBounds(manager, collider.bounds, offset, onlyRemoveSelectedPrototypes ? selectedPrototypes : null);
             }
             else
             {
                 GPUInstancerAPI.RemoveInstancesInsideCollider(manager, collider, offset, onlyRemoveSelectedPrototypes ? selectedPrototypes : null);
             }
         }
     }
 }
        private void SwitchCameras()
        {
            if (!FpsController || !FixedCamera)
            {
                return;
            }
            FpsController.SetActive(isCurrentCameraFixed);
            FixedCamera.SetActive(!isCurrentCameraFixed);

            var managers = FindObjectsOfType <GPUInstancerDetailManager>();

            foreach (var manager in managers)
            {
                GPUInstancerAPI.SetCamera(isCurrentCameraFixed
                    ? FpsController.GetComponentInChildren <Camera>()
                    : FixedCamera.GetComponentInChildren <Camera>());
            }

            if (!isCurrentCameraFixed)
            {
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible   = true;
            }
        }
Exemple #25
0
 private void DisableLoadingTerrainDetailsText()
 {
     _loadingTerrainDetailsText.SetActive(false);
     GPUInstancerAPI.StopListeningGPUIEvent(GPUInstancerEventType.DetailInitializationFinished, DisableLoadingTerrainDetailsText);
 }
Exemple #26
0
 public void SetCamera(Camera camera)
 {
     cameraData.mainCamera = camera;
     GPUInstancerAPI.SetCamera(camera);
 }
Exemple #27
0
 void Update()
 {
     // Update the variation buffer with a random set of colors every frame, thus changing instance colors per instance every frame.
     GPUInstancerAPI.UpdateVariation(prefabManager, goList[Random.Range(0, goList.Count)], bufferName, (Vector4)Random.ColorHSV());
 }