/// <summary>
/// Initializes instance.
/// </summary>
/// <param name="moc">Moc.</param>
private CubismUnmanagedModel(CubismUnmanagedMoc moc)
{
// Allocate and initialize memory (returning on fail).
var size = CubismCoreDll.GetSizeofModel(moc.Ptr);
var memory = CubismUnmanagedMemory.Allocate((int)size, CubismCoreDll.AlignofModel);
if (memory == IntPtr.Zero)
{
return;
}
// Initialize native model (cleaning up and returning on fail).
Ptr = CubismCoreDll.InitializeModelInPlace(moc.Ptr, memory, size);
if (Ptr == IntPtr.Zero)
{
CubismUnmanagedMemory.Deallocate(memory);
return;
}
// Initialize 'components'.
Parameters = new CubismUnmanagedParameters(Ptr);
Parts = new CubismUnmanagedParts(Ptr);
Drawables = new CubismUnmanagedDrawables(Ptr);
}
/// <summary>
/// Initializes instance.
/// </summary>
internal unsafe CubismUnmanagedParameters(IntPtr modelPtr)
{
var length = 0;
Count = CubismCoreDll.GetParameterCount(modelPtr);
length = CubismCoreDll.GetParameterCount(modelPtr);
Ids = new string[length];
var _ids = (IntPtr *)(CubismCoreDll.GetParameterIds(modelPtr));
for (var i = 0; i < length; ++i)
{
Ids[i] = Marshal.PtrToStringAnsi(_ids[i]);
}
length = CubismCoreDll.GetParameterCount(modelPtr);
MinimumValues = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetParameterMinimumValues(modelPtr), length);
length = CubismCoreDll.GetParameterCount(modelPtr);
MaximumValues = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetParameterMaximumValues(modelPtr), length);
length = CubismCoreDll.GetParameterCount(modelPtr);
DefaultValues = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetParameterDefaultValues(modelPtr), length);
length = CubismCoreDll.GetParameterCount(modelPtr);
Values = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetParameterValues(modelPtr), length);
}
/// <summary>
/// Initializes instance.
/// </summary>
/// <param name="modelPtr"> Native model pointer. </param>
internal unsafe CubismUnmanagedCanvasInfo(IntPtr modelPtr)
{
if (modelPtr == IntPtr.Zero)
{
return;
}
float[] _sizeXY = new float[2];
float[] _originXY = new float[2];
float[] _ppu = new float[1];
IntPtr size_ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(float)) * 2);
IntPtr origin_ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(float)) * 2);
IntPtr ppu_ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(float)) * 1);
CubismCoreDll.ReadCanvasInfo(modelPtr, size_ptr, origin_ptr, ppu_ptr);
Marshal.Copy(size_ptr, _sizeXY, 0, 2);
Marshal.Copy(origin_ptr, _originXY, 0, 2);
Marshal.Copy(ppu_ptr, _ppu, 0, 1);
Marshal.FreeCoTaskMem(size_ptr);
Marshal.FreeCoTaskMem(origin_ptr);
Marshal.FreeCoTaskMem(ppu_ptr);
CanvasWidth = _sizeXY[0];
CanvasHeight = _sizeXY[1];
CanvasOriginX = _originXY[0];
CanvasOriginY = _originXY[1];
PixelsPerUnit = _ppu[0];
}
/// <summary>
/// Updates instance.
/// </summary>
public void Update()
{
if (Ptr == IntPtr.Zero)
{
return;
}
CubismCoreDll.UpdateModel(Ptr);
}
/// <summary>
/// Initializes instance.
/// </summary>
internal unsafe CubismUnmanagedParts(IntPtr modelPtr)
{
var length = 0;
Count = CubismCoreDll.GetPartCount(modelPtr);
length = CubismCoreDll.GetPartCount(modelPtr);
Ids = new string[length];
var _ids = (IntPtr *)(CubismCoreDll.GetPartIds(modelPtr));
for (var i = 0; i < length; ++i)
{
Ids[i] = Marshal.PtrToStringAnsi(_ids[i]);
}
length = CubismCoreDll.GetPartCount(modelPtr);
Opacities = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetPartOpacities(modelPtr), length);
}
/// <summary>
/// Initializes instance.
/// </summary>
/// <param name="modelPtr"> Native model pointer. </param>
internal unsafe CubismUnmanagedCanvasInformation(IntPtr modelPtr)
{
if (modelPtr == IntPtr.Zero)
{
return;
}
float[] canvasSize = new float[2];
float[] canvasOrigin = new float[2];
float[] pixelsPerUnitBuffer = new float[1];
fixed(float *canvasSizePtr = canvasSize, canvasOriginPtr = canvasOrigin, pixelsPerUnitPtr = pixelsPerUnitBuffer)
{
CubismCoreDll.ReadCanvasInfo(modelPtr, (IntPtr)canvasSizePtr, (IntPtr)canvasOriginPtr, (IntPtr)pixelsPerUnitPtr);
CanvasWidth = canvasSize[0];
CanvasHeight = canvasSize[1];
CanvasOriginX = canvasOrigin[0];
CanvasOriginY = canvasOrigin[1];
PixelsPerUnit = pixelsPerUnitBuffer[0];
}
}
/// <summary>
/// Initializes instance.
/// </summary>
/// <param name="bytes">Moc bytes.</param>
private CubismUnmanagedMoc(byte[] bytes)
{
// Allocate and initialize memory (returning on fail).
var memory = CubismUnmanagedMemory.Allocate(bytes.Length, CubismCoreDll.AlignofMoc);
if (memory == IntPtr.Zero)
{
return;
}
CubismUnmanagedMemory.Write(bytes, memory);
// Revive native moc (cleaning up on fail).
Ptr = CubismCoreDll.ReviveMocInPlace(memory, (uint)bytes.Length);
if (Ptr == IntPtr.Zero)
{
CubismUnmanagedMemory.Deallocate(memory);
}
}
/// <summary>
/// Initializes instance.
/// </summary>
internal unsafe CubismUnmanagedDrawables(IntPtr modelPtr)
{
ModelPtr = modelPtr;
var length = 0;
CubismUnmanagedIntArrayView length2;
Count = CubismCoreDll.GetDrawableCount(modelPtr);
length = CubismCoreDll.GetDrawableCount(modelPtr);
Ids = new string[length];
var _ids = (IntPtr *)(CubismCoreDll.GetDrawableIds(modelPtr));
for (var i = 0; i < length; ++i)
{
Ids[i] = Marshal.PtrToStringAnsi(_ids[i]);
}
length = CubismCoreDll.GetDrawableCount(modelPtr);
ConstantFlags = new CubismUnmanagedByteArrayView(CubismCoreDll.GetDrawableConstantFlags(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
DynamicFlags = new CubismUnmanagedByteArrayView(CubismCoreDll.GetDrawableDynamicFlags(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
TextureIndices = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableTextureIndices(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
DrawOrders = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableDrawOrders(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
RenderOrders = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableRenderOrders(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
Opacities = new CubismUnmanagedFloatArrayView(CubismCoreDll.GetDrawableOpacities(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
MaskCounts = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableMaskCounts(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
VertexCounts = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableVertexCounts(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
IndexCounts = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableIndexCounts(modelPtr), length);
length = CubismCoreDll.GetDrawableCount(modelPtr);
length2 = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableMaskCounts(modelPtr), length);
Masks = new CubismUnmanagedIntArrayView[length];
var _masks = (IntPtr *)(CubismCoreDll.GetDrawableMasks(modelPtr));
for (var i = 0; i < length; ++i)
{
Masks[i] = new CubismUnmanagedIntArrayView(_masks[i], length2[i]);
}
length = CubismCoreDll.GetDrawableCount(modelPtr);
length2 = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableVertexCounts(modelPtr), length);
VertexPositions = new CubismUnmanagedFloatArrayView[length];
var _vertexPositions = (IntPtr *)(CubismCoreDll.GetDrawableVertexPositions(modelPtr));
for (var i = 0; i < length; ++i)
{
VertexPositions[i] = new CubismUnmanagedFloatArrayView(_vertexPositions[i], length2[i] * 2);
}
length = CubismCoreDll.GetDrawableCount(modelPtr);
length2 = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableVertexCounts(modelPtr), length);
VertexUvs = new CubismUnmanagedFloatArrayView[length];
var _vertexUvs = (IntPtr *)(CubismCoreDll.GetDrawableVertexUvs(modelPtr));
for (var i = 0; i < length; ++i)
{
VertexUvs[i] = new CubismUnmanagedFloatArrayView(_vertexUvs[i], length2[i] * 2);
}
length = CubismCoreDll.GetDrawableCount(modelPtr);
length2 = new CubismUnmanagedIntArrayView(CubismCoreDll.GetDrawableIndexCounts(modelPtr), length);
Indices = new CubismUnmanagedUshortArrayView[length];
var _indices = (IntPtr *)(CubismCoreDll.GetDrawableIndices(modelPtr));
for (var i = 0; i < length; ++i)
{
Indices[i] = new CubismUnmanagedUshortArrayView(_indices[i], length2[i]);
}
}
/// <summary>
/// Resets all dynamic drawable flags.
/// </summary>
public void ResetDynamicFlags()
{
CubismCoreDll.ResetDrawableDynamicFlags(ModelPtr);
}
