/// <summary>
/// Can be used to change the material of a prototype at runtime
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <param name="prototype">GPUI Prototype</param>
/// <param name="material">New material to set on the renderer</param>
/// <param name="lodLevel">LOD level</param>
/// <param name="rendererIndex">Renderer index on the LOD level</param>
/// <param name="subMeshIndex">Submesh index of the renderer</param>
public static void ChangeMaterial(GPUInstancerManager manager, GPUInstancerPrototype prototype, Material material, int lodLevel = 0, int rendererIndex = 0, int subMeshIndex = 0)
{
GPUInstancerRuntimeData runtimeData = manager.GetRuntimeData(prototype, true);
if (runtimeData == null)
{
return;
}
GPUInstancerRenderer gpuiRenderer = runtimeData.instanceLODs[lodLevel].renderers[rendererIndex];
// Generate proxy GO with a Mesh Renderer to get material property blocks
GameObject proxyGameObject = new GameObject("ProxyGO");
MeshFilter meshFilter = proxyGameObject.AddComponent <MeshFilter>();
MeshRenderer proxyRenderer = proxyGameObject.AddComponent <MeshRenderer>();
// Set mesh to proxy GO
meshFilter.mesh = gpuiRenderer.mesh;
// Set new material to runtime data
gpuiRenderer.materials[subMeshIndex] = GPUInstancerConstants.gpuiSettings.shaderBindings.GetInstancedMaterial(material);
// Set new material to proxy GO
proxyRenderer.materials[subMeshIndex] = material;
// Get material property blocks
proxyRenderer.GetPropertyBlock(gpuiRenderer.mpb);
if (gpuiRenderer.shadowMPB != null)
{
proxyRenderer.GetPropertyBlock(gpuiRenderer.shadowMPB);
}
// Destroy proxy GO
GameObject.Destroy(proxyGameObject);
// Setup new materials for instancing
GPUInstancerUtility.SetAppendBuffers(runtimeData);
}
/// <summary>
/// Can be used to change the mesh of a prototype at runtime
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <param name="prototype">GPUI Prototype</param>
/// <param name="mesh">New mesh to set on the renderer</param>
/// <param name="lodLevel">LOD level</param>
/// <param name="rendererIndex">Renderer index on the LOD level</param>
/// <param name="subMeshIndex">Submesh index of the renderer</param>
public static void ChangeMesh(GPUInstancerManager manager, GPUInstancerPrototype prototype, Mesh mesh, int lodLevel = 0, int rendererIndex = 0, int subMeshIndex = 0)
{
GPUInstancerRuntimeData runtimeData = manager.GetRuntimeData(prototype, true);
if (runtimeData == null)
{
return;
}
GPUInstancerRenderer gpuiRenderer = runtimeData.instanceLODs[lodLevel].renderers[rendererIndex];
if (gpuiRenderer.mesh.subMeshCount != mesh.subMeshCount)
{
Debug.LogError("ChangeMesh method can not be used with a mesh that has different amount of submeshes than the original mesh.");
return;
}
if (gpuiRenderer.mesh.vertexCount != mesh.vertexCount)
{
int argsLastIndex = gpuiRenderer.argsBufferOffset;
// Setup the indirect renderer buffer:
for (int j = 0; j < gpuiRenderer.mesh.subMeshCount; j++)
{
runtimeData.args[argsLastIndex++] = gpuiRenderer.mesh.GetIndexCount(j); // index count per instance
runtimeData.args[argsLastIndex++] = 0; // (uint)runtimeData.bufferSize;
runtimeData.args[argsLastIndex++] = gpuiRenderer.mesh.GetIndexStart(j); // start index location
runtimeData.args[argsLastIndex++] = 0; // base vertex location
runtimeData.args[argsLastIndex++] = 0; // start instance location
}
runtimeData.argsBuffer.SetData(runtimeData.args);
}
gpuiRenderer.mesh = mesh;
}
protected override void OnEnable()
{
base.OnEnable();
prototypeContents = null;
_pickerOverride = null;
_manager = (target as GPUInstancerManager);
FillPrototypeList();
prop_useFloatingOriginHandler = serializedObject.FindProperty("useFloatingOriginHandler");
prop_floatingOriginTransform = serializedObject.FindProperty("floatingOriginTransform");
prop_layerMask = serializedObject.FindProperty("layerMask");
prop_disableLightProbes = serializedObject.FindProperty("lightProbeDisabled");
showSceneSettingsBox = _manager.showSceneSettingsBox;
showPrototypeBox = _manager.showPrototypeBox;
showAdvancedBox = _manager.showAdvancedBox;
showHelpText = _manager.showHelpText;
showDebugBox = _manager.showDebugBox;
showGlobalValuesBox = _manager.showGlobalValuesBox;
showRegisteredPrefabsBox = _manager.showRegisteredPrefabsBox;
showPrototypesBox = _manager.showPrototypesBox;
}
private void Reset()
{
if (GetComponent <GPUInstancerManager>() != null)
{
gPUIManager = GetComponent <GPUInstancerManager>();
}
}
/// <summary>
/// [EDITOR-ONLY] Stops rendering GPUI instances for the given manager in editor mode. Can be used after StartEditorSimulation method to disable rendering.
/// </summary>
/// <param name="manager">GPUI manager to stop simulation for</param>
public static void StopEditorSimulation(GPUInstancerManager manager)
{
if (!Application.isPlaying && manager.gpuiSimulator != null)
{
manager.gpuiSimulator.StopSimulation();
}
}
protected override void OnEnable()
{
base.OnEnable();
prototypeContents = null;
_manager = (target as GPUInstancerManager);
FillPrototypeList();
}
/// <summary>
/// Returns the array that stores the transform data of the instances
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <param name="prototype">GPUI Prototype</param>
/// <returns>Instance data array</returns>
public static Matrix4x4[] GetInstanceDataArray(GPUInstancerManager manager, GPUInstancerPrototype prototype)
{
GPUInstancerRuntimeData runtimeData = manager.GetRuntimeData(prototype, true);
if (runtimeData == null)
{
return(null);
}
return(runtimeData.instanceDataArray);
}
public void SetDefaultGPUInstancerBillboardAtlasBindings()
{
if (billboardAtlasBindings == null)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
Undo.RecordObject(this, "GPUInstancerBillboardAtlasBindings instance generated");
}
#endif
billboardAtlasBindings = GPUInstancerManager.GetDefaultGPUInstancerBillboardAtlasBindings();
}
}
/// <summary>
/// SetInstanceCount can be used to discard instances that are indexed higher than the given index count
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <param name="prototype">GPUI Prototype</param>
/// <param name="instanceCount">New instance count to set on the runtime data</param>
public static void SetInstanceCount(GPUInstancerManager manager, GPUInstancerPrototype prototype, int instanceCount)
{
GPUInstancerRuntimeData runtimeData = manager.GetRuntimeData(prototype, true);
if (runtimeData == null)
{
return;
}
if (instanceCount > runtimeData.bufferSize)
{
Debug.LogError("Instance count can not be higher than the buffer size.");
return;
}
runtimeData.instanceCount = instanceCount;
}
public GPUInstancerEditorSimulator(GPUInstancerManager gpuiManager)
{
this.gpuiManager = gpuiManager;
if (sceneViewCameraData == null)
{
sceneViewCameraData = new GPUInstancerCameraData(null);
}
sceneViewCameraData.renderOnlySelectedCamera = true;
if (gpuiManager != null)
{
EditorApplication.update -= FindSceneViewCamera;
EditorApplication.update += FindSceneViewCamera;
#if UNITY_2017_2_OR_NEWER
EditorApplication.pauseStateChanged -= HandlePauseStateChanged;
EditorApplication.pauseStateChanged += HandlePauseStateChanged;
#else
EditorApplication.playmodeStateChanged = HandlePlayModeStateChanged;
#endif
}
}
/// <summary>
/// Removes the instances in GPU memory that are inside collider.
/// </summary>
/// <param name="manager">GPUI Manager to remove the instances from</param>
/// <param name="collider">Collider that define the area that the instances will be removed</param>
/// <param name="offset">Adds an offset around the area that the instances will be removed</param>
/// <param name="prototypeFilter">If prototypeFilter parameter is given, only the instances of the given prototypes will be removed.</param>
public static void RemoveInstancesInsideCollider(GPUInstancerManager manager, Collider collider, float offset = 0, List <GPUInstancerPrototype> prototypeFilter = null)
{
manager.RemoveInstancesInsideCollider(collider, offset, prototypeFilter);
}
/// <summary>
/// [For Advanced Users Only] Returns the float4x4 ComputeBuffer that store the localToWorldMatrix for each instance in GPU memory. This buffer can be used to make
/// modifications in GPU memory before the rendering process.
/// </summary>
/// <param name="manager">GPUI Manager to get the buffer from</param>
/// <param name="prototype">Prototype that the buffer belongs to</param>
/// <returns></returns>
public static ComputeBuffer GetTransformDataBuffer(GPUInstancerManager manager, GPUInstancerPrototype prototype)
{
return(manager.GetTransformDataBuffer(prototype));
}
/// <summary>
/// Changes the LODBias with the given value. Values lower than the LODBias in your Quality Settings will result in higher quality
/// but less performance (e.g. more instances will use LOD0), values higher than the LODBias in your Quality Settings will
/// reduce the quality but increase performance (e.g. less instances will use LOD0)
/// </summary>
/// <param name="manager">GPUI Manager to adjust the LOD sizes</param>
/// <param name="newLODBias">New LODBias value</param>
/// <param name="prototypeFilter">If prototypeFilter parameter is given, only the LODBiases of the given prototypes will be changed.</param>
public static void SetLODBias(GPUInstancerManager manager, float newLODBias, List <GPUInstancerPrototype> prototypeFilter = null)
{
manager.SetLODBias(newLODBias, prototypeFilter);
}
/// <summary>
/// Updates all transform values in GPU memory with the given offset position.
/// </summary>
/// <param name="manager">GPUI Manager to apply the offset</param>
/// <param name="offsetPosition">Offset Position</param>
public static void SetGlobalPositionOffset(GPUInstancerManager manager, Vector3 offsetPosition)
{
GPUInstancerUtility.SetGlobalPositionOffset(manager, offsetPosition);
}
/// <summary>
/// <para>Main GPU Instancer initialization Method. Generates the necessary GPUInstancer runtime data from predifined
/// GPU Instancer prototypes that are registered in the manager, and generates all necessary GPU buffers for instancing.</para>
/// <para>Use this as the final step after you setup a GPU Instancer manager and all its prototypes.</para>
/// <para>Note that you can also use this to re-initialize the GPU Instancer prototypes that are registered in the manager at runtime.</para>
/// </summary>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="forceNew">If set to false the manager will not run initialization if it was already initialized before</param>
public static void InitializeGPUInstancer(GPUInstancerManager manager, bool forceNew = true)
{
manager.InitializeRuntimeDataAndBuffers(forceNew);
}
/// <summary>
/// <para>Sets the active camera for a specific manager. This camera is used by GPU Instancer for various calculations (including culling operations). </para>
/// <para>Use this right after you add or change your camera at runtime. </para>
/// </summary>
/// <param name="manager">The manager that defines the prototypes you want to GPU instance.</param>
/// <param name="camera">The camera that GPU Instancer will use.</param>
public static void SetCamera(GPUInstancerManager manager, Camera camera)
{
manager.SetCamera(camera);
}
/// <summary>
/// Returns the prototype list of the given GPUI manager
/// </summary>
/// <param name="manager">GPUI Manager</param>
/// <returns>Prototype List</returns>
public static List <GPUInstancerPrototype> GetPrototypeList(GPUInstancerManager manager)
{
return(manager.prototypeList.ToList());
}
/// <summary>
/// Removes the instances in GPU memory that are inside bounds.
/// </summary>
/// <param name="manager">GPUI Manager to remove the instances from</param>
/// <param name="bounds">Bounds that define the area that the instances will be removed</param>
/// <param name="offset">Adds an offset around the area that the instances will be removed</param>
/// <param name="prototypeFilter">If prototypeFilter parameter is given, only the instances of the given prototypes will be removed.</param>
public static void RemoveInstancesInsideBounds(GPUInstancerManager manager, Bounds bounds, float offset = 0, List <GPUInstancerPrototype> prototypeFilter = null)
{
manager.RemoveInstancesInsideBounds(bounds, offset, prototypeFilter);
}
