public GlTextureBuffer(UInt32 target, UInt32 name, int width, int height,
GpuBufferFormat format, DeletionCallback callback, MpGlContext glContext)
{
deletionCallbackHandle = GCHandle.Alloc(callback, GCHandleType.Pinned);
ptr = UnsafeNativeMethods.MpGlTextureBufferCreate(
target, name, width, height, (UInt32)format, Marshal.GetFunctionPointerForDelegate(callback), glContext);
base.TakeOwnership(ptr);
}
/// <param name="callback">
/// A function called when the texture buffer is deleted.
/// Make sure that this function doesn't throw exceptions and won't be GCed.
/// </param>
public GlTextureBuffer(UInt32 target, UInt32 name, int width, int height,
GpuBufferFormat format, DeletionCallback callback, GlContext glContext)
{
var sharedContextPtr = glContext == null ? IntPtr.Zero : glContext.sharedPtr;
UnsafeNativeMethods.mp_SharedGlTextureBuffer__ui_ui_i_i_ui_PF_PSgc(
target, name, width, height, format, callback, sharedContextPtr, out var ptr).Assert();
sharedPtrHandle = new SharedPtr(ptr);
this.ptr = sharedPtrHandle.Get();
}
public static void RegisterForDeletionCallback <T>(ComPtr <T> ptr, DeletionCallback callback, object?data = null) where T : unmanaged
{
if (!ptr.TryQueryInterface <ID3DDestructionNotifier>(out var notifier))
{
ThrowHelper.ThrowArgumentException("Type could not query for interface ID3DDestructionNotifier");
}
using (notifier)
{
var nativeCallback = Marshal.GetFunctionPointerForDelegate(callback);
var handle = default(IntPtr);
if (data is object)
{
handle = GCHandle.ToIntPtr(GCHandle.Alloc(handle));
}
notifier.Get()->RegisterDestructionCallback(nativeCallback, (void *)handle, null);
}
}
public GlTextureBuffer(UInt32 name, int width, int height, GpuBufferFormat format, DeletionCallback callback, GlContext glContext = null) :
this(Gl.GL_TEXTURE_2D, name, width, height, format, callback, glContext)
{
}
public GlTextureBuffer(UInt32 name, int width, int height, GpuBufferFormat format, DeletionCallback callback) :
this(name, width, height, format, callback, IntPtr.Zero)
{
}
public GameObject[] splitByPlane(GameObject go, Vector4 plane, bool destroyOriginal)
{
if (go.GetComponentInChildren <SkinnedMeshRenderer>() != null)
{
return(splitByPlaneRD(go, plane, destroyOriginal));
}
Sliceable sliceable = ensureSliceable(go);
if (!sliceable.currentlySliceable)
{
GameObject[] result = { go };
return(result);
}
InfillConfiguration[] ourInfills = sliceable.infillers.Length > 0 ? sliceable.infillers : infills;
MeshCache c = null;
do
{
MeshFilter filter = getMeshFilter(sliceable);
Mesh m = filter.sharedMesh;
if (m == null)
{
break;
}
if (meshCaches != null && meshCaches.ContainsKey(m))
{
c = meshCaches[m];
//The mesh cache will be directly modified under the assumption that this will be discarded shortly
//and thus picked up by the GC. It will grow in size; it will not shrink. Thus we do not want to
//operate on the original, semi-persistent mesh caches that were preloaded on boot. Instead, we want
//to make a clone.
if (c.wasPreloaded)
{
c = c.clone();
}
}
else
{
c = cacheFromGameObject(sliceable, true);
}
}while(false);
if (c == null)
{
Debug.LogWarning("Turbo Slicer cannot find mesh filter in object '" + go.name + "' in scene '" + Application.loadedLevelName + "'! Only objects featuring a mesh filter can be sliced.");
GameObject[] result = { go };
return(result);
}
int submeshCount = c.indices.Length;
//We're going to create two new tentative meshes which contain ALL original vertices in order,
//plus room for new vertices. Not all of these copied vertices will be addressed, but copying them
//over eliminates the need to remove doubles and do an On^2 search.
TurboList <int>[] _frontIndices = new TurboList <int> [submeshCount];
TurboList <int>[] _backIndices = new TurboList <int> [submeshCount];
PlaneTriResult[] sidePlanes = new PlaneTriResult[c.vertices.Count];
{
Vector3[] vertices = c.vertices.array;
for (int i = 0; i < sidePlanes.Length; i++)
{
sidePlanes[i] = getSidePlane(ref vertices[i], ref plane);
}
}
for (int j = 0; j < submeshCount; j++)
{
int initialCapacityIndices = Mathf.RoundToInt((float)c.indices[j].Length * factorOfSafetyIndices);
_frontIndices[j] = new TurboList <int>(initialCapacityIndices);
_backIndices[j] = new TurboList <int>(initialCapacityIndices);
int[] _indices = c.indices[j];
TurboList <int> frontIndices = _frontIndices[j];
TurboList <int> backIndices = _backIndices[j];
TurboList <int> splitPending = new TurboList <int>(initialCapacityIndices);
int[] indices = new int[3];
for (int i = 0; i < _indices.Length;)
{
indices[0] = _indices[i++];
indices[1] = _indices[i++];
indices[2] = _indices[i++];
// compute the side of the plane each vertex is on
PlaneTriResult r1 = sidePlanes[indices[0]];
PlaneTriResult r2 = sidePlanes[indices[1]];
PlaneTriResult r3 = sidePlanes[indices[2]];
if (r1 == r2 && r1 == r3) // if all three vertices are on the same side of the plane.
{
if (r1 == PlaneTriResult.PTR_FRONT) // if all three are in front of the plane, then copy to the 'front' output triangle.
{
frontIndices.AddArray(indices);
}
else
{
backIndices.AddArray(indices);
}
}
else
{
splitPending.AddArray(indices);
}
}
InfillConfiguration ifc = null;
if (j < c.mats.Length)
{
Material mat = c.mats[j];
foreach (InfillConfiguration _ifc in ourInfills)
{
if (_ifc.material == mat)
{
ifc = _ifc;
}
}
}
splitTriangles(plane, splitPending.ToArray(), c, ifc, frontIndices, backIndices);
}
GameObject[] results;
bool onlyHaveOne = true;
for (int i = 0; i < c.indices.Length; i++)
{
onlyHaveOne &= _frontIndices[i].Count == 0 || _backIndices[i].Count == 0;
}
if (onlyHaveOne)
{
//Do nothing
results = new GameObject[1];
results[0] = go;
}
else
{
MeshCache frontCache = new MeshCache();
frontCache.vertices = c.vertices;
if (sliceable.channelNormals)
{
frontCache.normals = c.normals;
}
frontCache.UVs = c.UVs;
frontCache.mats = c.mats;
MeshCache backCache = new MeshCache();
backCache.vertices = c.vertices;
if (sliceable.channelNormals)
{
backCache.normals = c.normals;
}
backCache.UVs = c.UVs;
backCache.mats = c.mats;
frontCache.indices = new int[submeshCount][];
backCache.indices = new int[submeshCount][];
for (int i = 0; i < submeshCount; i++)
{
frontCache.indices[i] = _frontIndices[i].ToArray();
backCache.indices[i] = _backIndices[i].ToArray();
}
Vector3[] geoSubsetOne, geoSubsetTwo;
Vector3[] normalsSubsetOne = null, normalsSubsetTwo = null;
Vector2[] uvSubsetOne, uvSubsetTwo;
int[][] indexSubsetOne, indexSubsetTwo;
indexSubsetOne = new int[submeshCount][];
indexSubsetTwo = new int[submeshCount][];
//Perfect subset will inflate the array list size if needed to the exact figure. So if we estimate 0,
//and there is 1 submesh, than we will have 1 allocation, and this is optimal. Estimation can only help
//if we have THREE or more submeshes, which is a silly scenario for anyone concerned about performance.
int estimateOne = 0, estimateTwo = 0;
TurboList <Vector3>
_geoSubsetOne = null, _geoSubsetTwo = null,
_normalSubsetOne = null, _normalSubsetTwo = null;
TurboList <Vector2>
_uvSubsetOne = null, _uvSubsetTwo = null;
_geoSubsetOne = new TurboList <Vector3>(estimateOne);
_geoSubsetTwo = new TurboList <Vector3>(estimateTwo);
if (sliceable.channelNormals)
{
_normalSubsetOne = new TurboList <Vector3>(estimateOne);
_normalSubsetTwo = new TurboList <Vector3>(estimateTwo);
}
_uvSubsetOne = new TurboList <Vector2>(estimateOne);
_uvSubsetTwo = new TurboList <Vector2>(estimateTwo);
int transferTableMaximumKey = c.vertices.Count;
int[] transferTableOne = new int[transferTableMaximumKey];
int[] transferTableTwo = new int[transferTableMaximumKey];
for (int i = 0; i < transferTableOne.Length; i++)
{
transferTableOne[i] = -1;
}
for (int i = 0; i < transferTableTwo.Length; i++)
{
transferTableTwo[i] = -1;
}
for (int i = 0; i < submeshCount; i++)
{
perfectSubset(_frontIndices[i], c.vertices, c.normals, c.UVs, out indexSubsetOne[i], _geoSubsetOne, _normalSubsetOne, _uvSubsetOne, ref transferTableOne);
}
for (int i = 0; i < submeshCount; i++)
{
perfectSubset(_backIndices[i], c.vertices, c.normals, c.UVs, out indexSubsetTwo[i], _geoSubsetTwo, _normalSubsetTwo, _uvSubsetTwo, ref transferTableTwo);
}
geoSubsetOne = _geoSubsetOne.ToArray();
geoSubsetTwo = _geoSubsetTwo.ToArray();
if (sliceable.channelNormals)
{
normalsSubsetOne = _normalSubsetOne.ToArray();
normalsSubsetTwo = _normalSubsetTwo.ToArray();
}
uvSubsetOne = _uvSubsetOne.ToArray();
uvSubsetTwo = _uvSubsetTwo.ToArray();
//Note that we do not explicitly call recalculate bounds because (as per the manual) this is implicit in an
//assignment to vertices whenever the vertex count changes from zero to non-zero.
Mesh frontMesh = new Mesh();
Mesh backMesh = new Mesh();
GameObject frontObject, backObject;
createResultObjects(go, sliceable, false, plane, out frontObject, out backObject);
getMeshFilter(frontObject.GetComponent <Sliceable>()).mesh = frontMesh;
getMeshFilter(backObject.GetComponent <Sliceable>()).mesh = backMesh;
frontMesh.vertices = geoSubsetOne;
backMesh.vertices = geoSubsetTwo;
if (sliceable.channelNormals)
{
frontMesh.normals = normalsSubsetOne;
backMesh.normals = normalsSubsetTwo;
}
frontMesh.uv = uvSubsetOne;
backMesh.uv = uvSubsetTwo;
frontMesh.subMeshCount = submeshCount;
backMesh.subMeshCount = submeshCount;
for (int i = 0; i < submeshCount; i++)
{
frontMesh.SetTriangles(indexSubsetOne[i], i);
backMesh.SetTriangles(indexSubsetTwo[i], i);
}
if (meshCaches != null)
{
if (go.GetComponent <DeletionCallback>() == null)
{
frontObject.AddComponent <DeletionCallback>();
backObject.AddComponent <DeletionCallback>();
}
DeletionCallback frontCallback = frontObject.GetComponent <DeletionCallback>();
DeletionCallback backCallback = backObject.GetComponent <DeletionCallback>();
frontCallback.deletionListener = new DeletionOccurred(this.releaseCacheByMesh);
backCallback.deletionListener = new DeletionOccurred(this.releaseCacheByMesh);
frontCallback.mesh = frontMesh;
backCallback.mesh = backMesh;
meshCaches[frontMesh] = frontCache;
meshCaches[backMesh] = backCache;
}
else
{
DeletionCallback frontCallback = frontObject.GetComponent <DeletionCallback>();
DeletionCallback backCallback = backObject.GetComponent <DeletionCallback>();
if (frontCallback != null)
{
GameObject.DestroyImmediate(frontCallback);
}
if (backCallback != null)
{
GameObject.DestroyImmediate(backCallback);
}
}
if (destroyOriginal)
{
GameObject.Destroy(go);
}
results = new GameObject[2];
results[0] = frontObject;
results[1] = backObject;
if (sliceable != null && sliceable.refreshColliders)
{
foreach (GameObject r in results)
{
Collider collider = r.collider;
if (collider != null)
{
if (collider is BoxCollider)
{
GameObject.DestroyImmediate(collider);
r.AddComponent <BoxCollider>();
}
else if (collider is SphereCollider)
{
GameObject.DestroyImmediate(collider);
r.AddComponent <SphereCollider>();
}
else if (collider is MeshCollider)
{
MeshCollider mc = (MeshCollider)collider;
bool isFront = r == frontObject;
Mesh mesh = isFront ? frontMesh : backMesh;
mc.sharedMesh = mesh;
}
}
}
}
if (sliceable != null)
{
sliceable.handleSlice(results);
}
}
return(results);
}
