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());
}
public static void CheckPrefabRigidbodies(GPUInstancerPrefabPrototype prototype)
{
if (prototype.prefabObject != null && !prototype.meshRenderersDisabled)
{
EditorGUI.BeginChangeCheck();
Rigidbody rigidbody = prototype.prefabObject.GetComponent <Rigidbody>();
if (rigidbody != null)
{
prototype.hasRigidBody = true;
if (prototype.rigidbodyData == null)
{
prototype.rigidbodyData = new GPUInstancerPrefabPrototype.RigidbodyData();
}
prototype.rigidbodyData.useGravity = rigidbody.useGravity;
prototype.rigidbodyData.angularDrag = rigidbody.angularDrag;
prototype.rigidbodyData.mass = rigidbody.mass;
prototype.rigidbodyData.constraints = rigidbody.constraints;
prototype.rigidbodyData.drag = rigidbody.drag;
prototype.rigidbodyData.isKinematic = rigidbody.isKinematic;
prototype.rigidbodyData.interpolation = rigidbody.interpolation;
}
else
{
prototype.hasRigidBody = false;
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(prototype);
}
}
}
public override void DrawGPUInstancerPrototypeAdvancedActions()
{
if (Application.isPlaying)
{
return;
}
GUILayout.Space(10);
EditorGUILayout.BeginVertical();
// title
Rect foldoutRect = GUILayoutUtility.GetRect(0, 20, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
foldoutRect.x += 12;
showAdvancedBox = EditorGUI.Foldout(foldoutRect, showAdvancedBox, GPUInstancerEditorConstants.TEXT_advancedActions, true, GPUInstancerEditorConstants.Styles.foldout);
//GUILayout.Space(10);
if (showAdvancedBox)
{
EditorGUILayout.HelpBox(GPUInstancerEditorConstants.HELPTEXT_advancedActions, MessageType.Warning);
GPUInstancerPrefabPrototype prefabPrototype = (GPUInstancerPrefabPrototype)_prefabManager.selectedPrototype;
if (prefabPrototype != null)
{
if (prefabPrototype.meshRenderersDisabled)
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.enableMeshRenderers, GPUInstancerEditorConstants.Colors.green, Color.white, FontStyle.Bold, Rect.zero,
() =>
{
GPUInstancerPrefabManagerEditor.SetRenderersEnabled(prefabPrototype, true);
});
}
else
{
GPUInstancerEditorConstants.DrawColoredButton(GPUInstancerEditorConstants.Contents.disableMeshRenderers, GPUInstancerEditorConstants.Colors.lightBlue, Color.white, FontStyle.Bold, Rect.zero,
() =>
{
if (EditorUtility.DisplayDialog(GPUInstancerEditorConstants.TEXT_disableMeshRenderers, GPUInstancerEditorConstants.TEXT_disableMeshRenderersAreYouSure, "Yes", "No"))
{
GPUInstancerPrefabManagerEditor.SetRenderersEnabled(prefabPrototype, false);
}
});
}
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_disableMeshRenderers);
}
}
EditorGUILayout.EndVertical();
}
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));
}
}
}
public static void SetRenderersEnabled(GPUInstancerPrefabPrototype prefabPrototype, bool enabled)
{
#if UNITY_2018_3_OR_NEWER
GameObject prefabContents = GPUInstancerUtility.LoadPrefabContents(prefabPrototype.prefabObject);
#else
GameObject prefabContents = prefabPrototype.prefabObject;
#endif
MeshRenderer[] meshRenderers = prefabContents.GetComponentsInChildren <MeshRenderer>(true);
if (meshRenderers != null && meshRenderers.Length > 0)
{
for (int mr = 0; mr < meshRenderers.Length; mr++)
{
meshRenderers[mr].enabled = enabled;
}
}
BillboardRenderer[] billboardRenderers = prefabContents.GetComponentsInChildren <BillboardRenderer>(true);
if (billboardRenderers != null && billboardRenderers.Length > 0)
{
for (int mr = 0; mr < billboardRenderers.Length; mr++)
{
billboardRenderers[mr].enabled = enabled;
}
}
LODGroup lodGroup = prefabContents.GetComponent <LODGroup>();
if (lodGroup != null)
{
lodGroup.enabled = enabled;
}
if (prefabPrototype.hasRigidBody)
{
Rigidbody rigidbody = prefabContents.GetComponent <Rigidbody>();
if (enabled || prefabPrototype.autoUpdateTransformData)
{
if (rigidbody == null)
{
GPUInstancerPrefabPrototype.RigidbodyData rigidbodyData = prefabPrototype.rigidbodyData;
if (rigidbodyData != null)
{
rigidbody = prefabPrototype.prefabObject.AddComponent <Rigidbody>();
rigidbody.useGravity = rigidbodyData.useGravity;
rigidbody.angularDrag = rigidbodyData.angularDrag;
rigidbody.mass = rigidbodyData.mass;
rigidbody.constraints = rigidbodyData.constraints;
rigidbody.detectCollisions = true;
rigidbody.drag = rigidbodyData.drag;
rigidbody.isKinematic = rigidbodyData.isKinematic;
rigidbody.interpolation = rigidbodyData.interpolation;
}
}
}
else if (rigidbody != null && !prefabPrototype.autoUpdateTransformData)
{
DestroyImmediate(rigidbody, true);
}
}
#if UNITY_2018_3_OR_NEWER
GPUInstancerUtility.UnloadPrefabContents(prefabPrototype.prefabObject, prefabContents, true);
#endif
EditorUtility.SetDirty(prefabPrototype.prefabObject);
prefabPrototype.meshRenderersDisabled = !enabled;
EditorUtility.SetDirty(prefabPrototype);
}
/// <summary>
/// <para>Specifies a variation buffer for a GPU Instancer prototype that is defined in the prefab's shader. Required to use <see cref="AddVariation{T}"/></para>
/// <prara>Use this if you want any type of variation between this prototype's instances.</prara>
/// <para>To define the buffer necessary for this variation in your shader, you need to create a StructuredBuffer field of the relevant type in that shader.
/// You can then access this buffer with "gpuiTransformationMatrix[unity_InstanceID]"</para>
/// <para>see <seealso cref="ColorVariations"/> and its demo scene for an example</para>
/// </summary>
///
/// <example>
/// This sample shows how to use the variation buffer in your shader:
///
/// <code><![CDATA[
/// ...
/// fixed4 _Color;
///
/// #ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED
/// StructuredBuffer<float4> colorBuffer;
/// #endif
/// ...
/// void surf (Input IN, inout SurfaceOutputStandard o) {
/// ...
/// #ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED
/// uint index = gpuiTransformationMatrix[unity_InstanceID];
/// col = colorBuffer[index];
/// #else
/// col = _Color;
/// #endif
/// ...
/// }
/// ]]></code>
///
/// See "GPUInstancer/ColorVariationShader" for the full example.
///
/// </example>
///
/// <typeparam name="T">The type of variation buffer. Must be defined in the instance prototype's shader</typeparam>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="prototype">The GPU Instancer prototype to define variations.</param>
/// <param name="bufferName">The name of the variation buffer in the prototype's shader.</param>
public static void DefinePrototypeVariationBuffer <T>(GPUInstancerPrefabManager manager, GPUInstancerPrefabPrototype prototype, string bufferName)
{
manager.DefinePrototypeVariationBuffer <T>(prototype, bufferName);
}
/// <summary>
/// Use this method to add new instances to prototype when you do not use prefabs (Ex: when you create a prototype with DefineGameObjectAsPrefabPrototypeAtRuntime API method)
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prefabPrototype">GPUI Prefab Prototype</param>
/// <param name="instances">List of GameObjects to register on the manager</param>
public static void AddInstancesToPrefabPrototypeAtRuntime(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prefabPrototype, IEnumerable <GameObject> instances)
{
prefabManager.AddInstancesToPrefabPrototypeAtRuntime(prefabPrototype, instances);
}
/// <summary>
/// Use this method to remove a prototype definition at runtime
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prefabPrototype">GPUI Prefab Prototype ro remove from the manager</param>
public static void RemovePrototypeAtRuntime(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prefabPrototype)
{
prefabManager.RemovePrototypeAtRuntime(prefabPrototype);
}
/// <summary>
/// Use this method to update transform data of all prefab instances with a Matrix4x4 array. By default all the data from the array will be
/// uploaded to the GPU. You can make partial uploads by setting the arrayStartIndex, bufferStartIndex, and count parameters.
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prototype">GPUI Prefab Prototype</param>
/// <param name="matrix4x4Array">Array of Matrix4x4 that store the transform data of prefab instances</param>
/// <param name="arrayStartIndex">Start index of the given array that the data will be uploaded to the buffer</param>
/// <param name="bufferStartIndex">Start index of the buffer to set the data from the array</param>
/// <param name="count">Total number of matrices to set to the buffer from the array</param>
public static void UpdateVisibilityBufferWithMatrix4x4Array(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype, Matrix4x4[] matrix4x4Array,
int arrayStartIndex = 0, int bufferStartIndex = 0, int count = 0)
{
GPUInstancerUtility.UpdateVisibilityBufferWithMatrix4x4Array(prefabManager, prototype, matrix4x4Array, arrayStartIndex, bufferStartIndex, count);
}
/// <summary>
/// Initialize single prefab prototype for preparing runtime data and buffers for instanced rendering
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prefabPrototype">GPUI Prefab Prototype</param>
/// <returns></returns>
public static GPUInstancerRuntimeData InitializeGPUInstancer(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype)
{
// initialize PrefabManager if it is not already initialized
prefabManager.InitializeRuntimeDataAndBuffers(false);
// generate and return prototype runtime data
return(prefabManager.InitializeRuntimeDataForPrefabPrototype(prototype));
}
/// <summary>
/// Updates the variation values for the given array for the specified prototype and buffer.
/// </summary>
/// <typeparam name="T">The type of variation buffer. Must be defined in the instance prototype's shader</typeparam>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="prototype">The GPU Instancer prototype to define variations.</param>
/// <param name="bufferName">The name of the variation buffer in the prototype's shader.</param>
/// <param name="variationArray">The array that stores the variation information.</param>
/// <param name="arrayStartIndex">Start index of the given array that the data will be uploaded to the buffer</param>
/// <param name="bufferStartIndex">Start index of the buffer to set the data from the array</param>
/// <param name="count">Total number of variation data to set to the buffer from the array</param>
public static void UpdateVariationFromArray <T>(GPUInstancerPrefabManager manager, GPUInstancerPrefabPrototype prototype, string bufferName, T[] variationArray,
int arrayStartIndex = 0, int bufferStartIndex = 0, int count = 0)
{
manager.UpdateVariationsFromArray <T>(prototype, bufferName, variationArray, arrayStartIndex, bufferStartIndex, count);
}
/// <summary>
/// Use this method to create prefab instances with the given transform information without creating GameObjects.
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prototype">GPUI Prefab Prototype</param>
/// <param name="matrix4x4Array">Array of Matrix4x4 that store the transform data of prefab instances</param>
public static void InitializeWithMatrix4x4Array(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype, Matrix4x4[] matrix4x4Array)
{
GPUInstancerUtility.InitializeWithMatrix4x4Array(prefabManager, prototype, matrix4x4Array);
}
public static void DrawGPUInstancerPrototypeInfo(GPUInstancerPrototype selectedPrototype, UnityAction <string> DrawHelpText)
{
EditorGUILayout.BeginVertical(GPUInstancerEditorConstants.Styles.box);
GPUInstancerEditorConstants.DrawCustomLabel(GPUInstancerEditorConstants.TEXT_prefabRuntimeSettings, GPUInstancerEditorConstants.Styles.boldLabel);
GPUInstancerPrefabPrototype prototype = (GPUInstancerPrefabPrototype)selectedPrototype;
prototype.enableRuntimeModifications = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_enableRuntimeModifications, prototype.enableRuntimeModifications);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_enableRuntimeModifications);
EditorGUI.BeginDisabledGroup(!prototype.enableRuntimeModifications);
EditorGUI.BeginDisabledGroup(!prototype.hasRigidBody || prototype.autoUpdateTransformData);
prototype.startWithRigidBody = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_startWithRigidBody, prototype.startWithRigidBody);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_startWithRigidBody);
EditorGUI.EndDisabledGroup();
prototype.addRemoveInstancesAtRuntime = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_addRemoveInstancesAtRuntime, prototype.addRemoveInstancesAtRuntime);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRemoveInstancesAtRuntime);
EditorGUI.BeginDisabledGroup(!prototype.addRemoveInstancesAtRuntime);
prototype.extraBufferSize = EditorGUILayout.IntSlider(GPUInstancerEditorConstants.TEXT_extraBufferSize, prototype.extraBufferSize, 0, GPUInstancerConstants.PREFAB_EXTRA_BUFFER_SIZE);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_extraBufferSize);
prototype.addRuntimeHandlerScript = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_addRuntimeHandlerScript, prototype.addRuntimeHandlerScript);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_addRuntimeHandlerScript);
if (prototype.addRemoveInstancesAtRuntime && !Application.isPlaying)
{
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prototype.prefabObject.GetComponent <GPUInstancerPrefabRuntimeHandler>();
if (prototype.addRuntimeHandlerScript && prefabRuntimeHandler == null)
{
#if UNITY_2018_3_OR_NEWER
GPUInstancerUtility.AddComponentToPrefab <GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
#else
prototype.prefabObject.AddComponent <GPUInstancerPrefabRuntimeHandler>();
#endif
EditorUtility.SetDirty(prototype.prefabObject);
}
else if (!prototype.addRuntimeHandlerScript && prefabRuntimeHandler != null)
{
#if UNITY_2018_3_OR_NEWER
GPUInstancerUtility.RemoveComponentFromPrefab <GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
#else
DestroyImmediate(prefabRuntimeHandler, true);
#endif
EditorUtility.SetDirty(prototype.prefabObject);
}
}
EditorGUI.EndDisabledGroup();
bool autoUpdateTransformData = prototype.autoUpdateTransformData;
prototype.autoUpdateTransformData = EditorGUILayout.Toggle(GPUInstancerEditorConstants.TEXT_autoUpdateTransformData, prototype.autoUpdateTransformData);
DrawHelpText(GPUInstancerEditorConstants.HELPTEXT_autoUpdateTransformData);
if (autoUpdateTransformData != prototype.autoUpdateTransformData && prototype.meshRenderersDisabled)
{
SetRenderersEnabled(prototype, !prototype.meshRenderersDisabled);
}
EditorGUI.EndDisabledGroup();
if (!prototype.enableRuntimeModifications)
{
if (prototype.addRemoveInstancesAtRuntime)
{
prototype.addRemoveInstancesAtRuntime = false;
}
if (prototype.startWithRigidBody)
{
prototype.startWithRigidBody = false;
}
if (prototype.autoUpdateTransformData)
{
prototype.autoUpdateTransformData = false;
if (prototype.meshRenderersDisabled)
{
SetRenderersEnabled(prototype, !prototype.meshRenderersDisabled);
}
}
}
if ((!prototype.enableRuntimeModifications || !prototype.addRemoveInstancesAtRuntime) && prototype.extraBufferSize > 0)
{
prototype.extraBufferSize = 0;
}
if ((!prototype.enableRuntimeModifications || !prototype.addRemoveInstancesAtRuntime) && prototype.addRuntimeHandlerScript)
{
prototype.addRuntimeHandlerScript = false;
GPUInstancerPrefabRuntimeHandler prefabRuntimeHandler = prototype.prefabObject.GetComponent <GPUInstancerPrefabRuntimeHandler>();
if (prefabRuntimeHandler != null)
{
#if UNITY_2018_3_OR_NEWER
GPUInstancerUtility.RemoveComponentFromPrefab <GPUInstancerPrefabRuntimeHandler>(prototype.prefabObject);
#else
DestroyImmediate(prefabRuntimeHandler, true);
#endif
EditorUtility.SetDirty(prototype.prefabObject);
}
}
EditorGUILayout.EndVertical();
}
/// <summary>
/// Specifies a variation buffer for a GPU Instancer prototype that is defined in the prefab's shader. And sets the variation values for the given array.
/// </summary>
/// <typeparam name="T">The type of variation buffer. Must be defined in the instance prototype's shader</typeparam>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="prototype">The GPU Instancer prototype to define variations.</param>
/// <param name="bufferName">The name of the variation buffer in the prototype's shader.</param>
/// <param name="variationArray">The array that stores the variation information.</param>
public static void DefineAndAddVariationFromArray <T>(GPUInstancerPrefabManager manager, GPUInstancerPrefabPrototype prototype, string bufferName, T[] variationArray)
{
manager.DefineAndAddVariationFromArray <T>(prototype, bufferName, variationArray);
}
/// <summary>
/// Use this method to update transform data of all prefab instances with a Matrix4x4 array
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prototype">GPUI Prefab Prototype</param>
/// <param name="matrix4x4Array">Array of Matrix4x4 that store the transform data of prefab instances</param>
public static void UpdateVisibilityBufferWithMatrix4x4Array(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype, Matrix4x4[] matrix4x4Array)
{
GPUInstancerUtility.UpdateVisibilityBufferWithMatrix4x4Array(prefabManager, prototype, matrix4x4Array);
}
/// <summary>
/// Updates the variation values for the given array for the specified prototype and buffer.
/// </summary>
/// <typeparam name="T">The type of variation buffer. Must be defined in the instance prototype's shader</typeparam>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="prototype">The GPU Instancer prototype to define variations.</param>
/// <param name="bufferName">The name of the variation buffer in the prototype's shader.</param>
/// <param name="variationArray">The array that stores the variation information.</param>
public static void UpdateVariationFromArray <T>(GPUInstancerPrefabManager manager, GPUInstancerPrefabPrototype prototype, string bufferName, T[] variationArray)
{
manager.UpdateVariationsFromArray <T>(prototype, bufferName, variationArray);
}
/// <summary>
/// Use this method to update transform data of all prefab instances with a float4x4 native array. By default all the data from the array will be
/// uploaded to the GPU. You can make partial uploads by setting the arrayStartIndex, bufferStartIndex, and count parameters.
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prototype">GPUI Prefab Prototype</param>
/// <param name="float4x4Array">Array of float4x4 that store the transform data of prefab instances. Struct reference is not forced so you can use any float4x4 struct (e.g. Matrix4x4 or float4x4 from Mathematics package)</param>
/// <param name="arrayStartIndex">(Optional) Start index of the given array that the data will be uploaded to the buffer</param>
/// <param name="bufferStartIndex">(Optional) Start index of the buffer to set the data from the array</param>
/// <param name="count">(Optional) Total number of matrices to set to the buffer from the array</param>
public static void UpdateVisibilityBufferWithNativeArray <T>(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype, NativeArray <T> float4x4Array,
int arrayStartIndex = 0, int bufferStartIndex = 0, int count = 0) where T : struct
{
GPUInstancerUtility.UpdateVisibilityBufferWithNativeArray(prefabManager, prototype, float4x4Array, arrayStartIndex, bufferStartIndex, count);
}
/// <summary>
/// Use this method to initialize buffers for the given prototype and set the buffer data later with UpdateVisibilityBuffer API methods. Please note that you will
/// need to provide a positive integer buffer size to initialize the buffers successfully.
/// </summary>
/// <param name="prefabManager">The GPUI Prefab Manager that the prefab prototype is defined on</param>
/// <param name="prototype">GPUI Prefab Prototype</param>
/// <param name="bufferSize">Size of the buffer to allocate in GPU memory</param>
/// <param name="instanceCount">(Optional) Initial instance count to render. Can also be set later with SetInstanceCount API method</param>
public static void InitializePrototype(GPUInstancerPrefabManager prefabManager, GPUInstancerPrefabPrototype prototype, int bufferSize, int instanceCount = 0)
{
GPUInstancerUtility.InitializePrototype(prefabManager, prototype, bufferSize, instanceCount);
}
/// <summary>
/// Specifies a variation buffer for a GPU Instancer prototype that is defined in the prefab's shader. And sets the variation values for the given array.
/// </summary>
/// <typeparam name="T">The type of variation buffer. Must be defined in the instance prototype's shader</typeparam>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="prototype">The GPU Instancer prototype to define variations.</param>
/// <param name="bufferName">The name of the variation buffer in the prototype's shader.</param>
/// <param name="variationArray">The array that stores the variation information.</param>
public static PrefabVariationData <T> DefineAndAddVariationFromArray <T>(GPUInstancerPrefabManager manager, GPUInstancerPrefabPrototype prototype, string bufferName, T[] variationArray)
{
return(manager.DefineAndAddVariationFromArray <T>(prototype, bufferName, variationArray));
}
