/// <summary>
/// </summary>
/// <param name="entry">
/// </param>
/// <param name="block">
/// </param>
public static void CreationFuncForMeshes(AbstractMesh entry, OctreeBlock <AbstractMesh> block)
{
if (entry.getBoundingInfo().boundingBox.intersectsMinMax(block.minPoint, block.maxPoint))
{
block.entries.Add(entry);
}
}
/// <summary>
/// </summary>
/// <param name="materialIndex">
/// </param>
/// <param name="verticesStart">
/// </param>
/// <param name="verticesCount">
/// </param>
/// <param name="indexStart">
/// </param>
/// <param name="indexCount">
/// </param>
/// <param name="mesh">
/// </param>
/// <param name="renderingMesh">
/// </param>
/// <param name="createBoundingBox">
/// </param>
public SubMesh(
int materialIndex,
int verticesStart,
int verticesCount,
int indexStart,
int indexCount,
AbstractMesh mesh,
Mesh renderingMesh = null,
bool createBoundingBox = true)
{
this.materialIndex = materialIndex;
this.verticesStart = verticesStart;
this.verticesCount = verticesCount;
this.indexStart = indexStart;
this.indexCount = indexCount;
this._mesh = mesh;
this._renderingMesh = renderingMesh ?? (Mesh)mesh;
mesh.subMeshes.Add(this);
this._id = mesh.subMeshes.Length - 1;
if (createBoundingBox)
{
this.refreshBoundingInfo();
}
}
/// <summary>
/// </summary>
/// <param name="newMesh">
/// </param>
/// <param name="newRenderingMesh">
/// </param>
/// <returns>
/// </returns>
public virtual SubMesh clone(AbstractMesh newMesh, Mesh newRenderingMesh = null)
{
var result = new SubMesh(
this.materialIndex, this.verticesStart, this.verticesCount, this.indexStart, this.indexCount, newMesh, newRenderingMesh, false);
result._boundingInfo = new BoundingInfo(this._boundingInfo.minimum, this._boundingInfo.maximum);
return(result);
}
public async ValueTask addCPUSkinningFallback(decimal rank, AbstractMesh mesh)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "addCPUSkinningFallback" }, rank, mesh
}
);
}
public async ValueTask <bool> canAffectMesh(AbstractMesh mesh)
{
return(await EventHorizonBlazorInterop.Func <bool>(
new object[]
{
new string[] { this.___guid, "canAffectMesh" }, mesh
}
));
}
public ValueTask set_meshMap(AbstractMesh value)
{
__meshMap = null;
return(EventHorizonBlazorInterop.Set(
this.___guid,
"meshMap",
value
));
}
public async ValueTask forceCompilation(AbstractMesh mesh, ActionCallback <Material> onCompiled = null, IMaterialCompilationOptions options = null, ActionCallback <string> onError = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "forceCompilation" }, mesh, onCompiled, options, onError
}
);
}
public async ValueTask start(AbstractMesh emitter = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "start" }, emitter
}
);
}
public ValueTask set_originMesh(AbstractMesh value)
{
__originMesh = null;
return(EventHorizonBlazorInterop.Set(
this.___guid,
"originMesh",
value
));
}
public async ValueTask setTarget(AbstractMesh target, System.Nullable <bool> toBoundingCenter = null, System.Nullable <bool> allowSamePosition = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "setTarget" }, target, toBoundingCenter, allowSamePosition
}
);
}
public bool needAlphaBlendingForMesh(AbstractMesh mesh)
{
return(EventHorizonBlazorInterop.Func <bool>(
new object[]
{
new string[] { this.___guid, "needAlphaBlendingForMesh" }, mesh
}
));
}
public async ValueTask prepareDefines(AbstractMesh mesh, NodeMaterial nodeMaterial, NodeMaterialDefines defines)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "prepareDefines" }, mesh, nodeMaterial, defines
}
);
}
public void getPositionToRef(AbstractMesh mesh, Vector3 result, System.Nullable <int> space = null)
{
EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "getPositionToRef" }, space, mesh, result
}
);
}
public void translate(Vector3 vec, System.Nullable <int> space = null, AbstractMesh mesh = null)
{
EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "translate" }, vec, space, mesh
}
);
}
public void initializeDefines(AbstractMesh mesh, NodeMaterial nodeMaterial, NodeMaterialDefines defines, System.Nullable <bool> useInstances = null)
{
EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "initializeDefines" }, mesh, nodeMaterial, defines, useInstances
}
);
}
public async ValueTask getRotationMatrixToRef(AbstractMesh mesh, Matrix result, System.Nullable <int> space = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "getRotationMatrixToRef" }, space, mesh, result
}
);
}
public bool isReady(AbstractMesh mesh = null, System.Nullable <bool> useInstances = null)
{
return(EventHorizonBlazorInterop.Func <bool>(
new object[]
{
new string[] { this.___guid, "isReady" }, mesh, useInstances
}
));
}
public async ValueTask provideFallbacks(AbstractMesh mesh, EffectFallbacks fallbacks)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "provideFallbacks" }, mesh, fallbacks
}
);
}
public decimal[] getTransformMatrices(AbstractMesh mesh)
{
return(EventHorizonBlazorInterop.FuncArray <decimal>(
new object[]
{
new string[] { this.___guid, "getTransformMatrices" }, mesh
}
));
}
public async ValueTask prepareDefines(AbstractMesh mesh, NodeMaterial nodeMaterial, NodeMaterialDefines defines, System.Nullable <bool> useInstances = null, SubMesh subMesh = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "prepareDefines" }, mesh, nodeMaterial, defines, useInstances, subMesh
}
);
}
public async ValueTask zoomOnMeshHierarchy(AbstractMesh mesh, System.Nullable <bool> focusOnOriginXZ = null, ActionCallback onAnimationEnd = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "zoomOnMeshHierarchy" }, mesh, focusOnOriginXZ, onAnimationEnd
}
);
}
public async ValueTask <bool> isReady(AbstractMesh mesh, NodeMaterial nodeMaterial, NodeMaterialDefines defines, System.Nullable <bool> useInstances = null)
{
return(await EventHorizonBlazorInterop.Func <bool>(
new object[]
{
new string[] { this.___guid, "isReady" }, mesh, nodeMaterial, defines, useInstances
}
));
}
public async ValueTask <bool> isReadyForSubMesh(AbstractMesh mesh, SubMesh subMesh, System.Nullable <bool> useInstances = null)
{
return(await EventHorizonBlazorInterop.Func <bool>(
new object[]
{
new string[] { this.___guid, "isReadyForSubMesh" }, mesh, subMesh, useInstances
}
));
}
/// <summary>
/// </summary>
/// <param name="mesh">
/// </param>
/// <param name="precise">
/// </param>
/// <returns>
/// </returns>
public virtual bool intersectsMesh(AbstractMesh mesh, bool precise = false)
{
if (this._boundingInfo == null || mesh._boundingInfo == null)
{
return(false);
}
return(this._boundingInfo.intersects(mesh._boundingInfo, precise));
}
public async ValueTask forceCompilationAsync(AbstractMesh mesh, IMaterialCompilationOptions options = null)
{
await EventHorizonBlazorInterop.Task <CachedEntity>(
new object[]
{
new string[] { this.___guid, "forceCompilationAsync" }, mesh, options
}
);
}
public async ValueTask setAbsolutePosition(Vector3 position, AbstractMesh mesh = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "setAbsolutePosition" }, position, mesh
}
);
}
public async ValueTask getAbsolutePositionToRef(AbstractMesh mesh, Vector3 result)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "getAbsolutePositionToRef" }, mesh, result
}
);
}
public async ValueTask getDirectionToRef(Vector3 localAxis, Vector3 result, AbstractMesh mesh = null)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "getDirectionToRef" }, localAxis, mesh, result
}
);
}
public static async ValueTask Parse(object parsedActions, AbstractMesh @object, Scene scene)
{
await EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { "BABYLON", "ActionManager", "Parse" }, parsedActions, @object, scene
}
);
}
public void start(AbstractMesh emitter = null)
{
EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "start" }, emitter
}
);
}