public MainItemVO(MainItemVO vo)
{
uniqueId = vo.uniqueId;
itemIdentifier = vo.itemIdentifier;
itemName = vo.itemName;
if (tags != null)
{
tags = (string[])vo.tags.Clone();
}
customVars = vo.customVars;
x = vo.x;
y = vo.y;
rotation = vo.rotation;
zIndex = vo.zIndex;
layerName = vo.layerName;
if (vo.tint != null)
{
tint = (float[])vo.tint.Clone();
}
scaleX = vo.scaleX;
scaleY = vo.scaleY;
originX = vo.originX;
originY = vo.originY;
if (vo.shape != null)
{
shape = vo.shape.clone();
}
if (vo.physics != null)
{
physics = new PhysicsBodyDataVO(vo.physics);
}
}
/// <summary>
/// gets the layerDepth for a child composite. It calculates it by first getting the composite (parent) layerDepth the standard way
/// (via zIndexMaxComp) and then subtracting the inverse of the child (O2DMainItem) layerDepth which uses zIndexMaxChild. For this to
/// work intelligently zIndexMaxComp should be the standard scene.zIndexMax value and zIndexMaxChild should be a much higher number. The
/// reason for this is so that the parent component has a small offset to use for each child and so they dont overflow to the next zIndex.
///
/// Example: parent is 14. Any children must end up being between 14 and 15 so they dont overflow on top of another composite.
/// </summary>
/// <returns>The depth for child.</returns>
/// <param name="zIndexMaxComp">Z index max comp.</param>
/// <param name="child">Child.</param>
/// <param name="zIndexMaxChild">Z index max child.</param>
public float calculateLayerDepthForChild(float zIndexMax, MainItemVO child, float zIndexMaxChild = 100)
{
if (zIndexMaxChild < zIndexMax)
{
zIndexMaxChild = zIndexMax * 10;
}
return(calculateLayerDepth(zIndexMax, null) - (1 - child.calculateLayerDepth(zIndexMaxChild, null)));
}
public void removeItem(MainItemVO vo)
{
Type classType = vo.GetType();
if (classType.Name == "SimpleImageVO")
{
sImages.Remove((SimpleImageVO)vo);
}
if (classType.Name == "Image9patchVO")
{
sImage9patchs.Remove((Image9patchVO)vo);
}
if (classType.Name == "TextBoxVO")
{
sTextBox.Remove((TextBoxVO)vo);
}
if (classType.Name == "LabelVO")
{
sLabels.Remove((LabelVO)vo);
}
if (classType.Name == "CompositeItemVO")
{
sComposites.Remove((CompositeItemVO)vo);
}
if (classType.Name == "SelectBoxVO")
{
sSelectBoxes.Remove((SelectBoxVO)vo);
}
if (classType.Name == "ParticleEffectVO")
{
sParticleEffects.Remove((ParticleEffectVO)vo);
}
if (classType.Name == "LightVO")
{
sLights.Remove((LightVO)vo);
}
if (classType.Name == "SpineVO")
{
sSpineAnimations.Remove((SpineVO)vo);
}
if (classType.Name == "SpriteAnimationVO")
{
sSpriteAnimations.Remove((SpriteAnimationVO)vo);
}
if (classType.Name == "SpriterVO")
{
sSpriterAnimations.Remove((SpriterVO)vo);
}
if (classType.Name == "ColorPrimitiveVO")
{
sColorPrimitives.Remove((ColorPrimitiveVO)vo);
}
}
/// <summary>
/// gets the layerDepth for a child composite. It calculates it by first getting the composite (parent) layerDepth the standard way
/// (via zIndexMin/Max) and then subtracting the inverse of the child (O2DMainItem) layerDepth which uses zIndexMaxChild. For this to
/// work intelligently zIndexMaxComp should be the standard scene.zIndexMax value and zIndexMaxChild should be a much higher number. The
/// reason for this is so that the parent component has a small offset to use for each child and so they dont overflow to the next zIndex.
///
/// Example: parent is 14. Any children must end up being between 14 and 15 so they dont overflow on top of another composite.
/// </summary>
/// <returns>The depth for child.</returns>
/// <param name="zIndexMaxComp">Z index max comp.</param>
/// <param name="child">Child.</param>
/// <param name="zIndexMaxChild">Z index max child.</param>
public float calculateLayerDepthForChild( float zIndexMin, float zIndexMax, MainItemVO child, float zIndexMaxChild = 100 )
{
if( zIndexMaxChild < zIndexMax )
zIndexMaxChild = zIndexMax * 10;
if( child.zIndex < zIndex )
child.zIndex = zIndex + 1;
var ourLayerDepth = calculateLayerDepth( zIndexMin, zIndexMax, null );
var childLayerDepth = child.calculateLayerDepth( zIndexMin, zIndexMax, null );
return Mathf.clamp01( ourLayerDepth + childLayerDepth );
//return calculateLayerDepth( zIndexMin, zIndexMax, null ) - ( 1 - child.calculateLayerDepth( zIndexMin, zIndexMax, null ) );
}
/// <summary>
/// gets the layerDepth for a child composite. It calculates it by first getting the composite (parent) layerDepth the standard way
/// (via zIndexMin/Max) and then subtracting the inverse of the child (O2DMainItem) layerDepth which uses zIndexMaxChild. For this to
/// work intelligently zIndexMaxComp should be the standard scene.zIndexMax value and zIndexMaxChild should be a much higher number. The
/// reason for this is so that the parent component has a small offset to use for each child and so they dont overflow to the next zIndex.
///
/// Example: parent is 14. Any children must end up being between 14 and 15 so they dont overflow on top of another composite.
/// </summary>
/// <returns>The depth for child.</returns>
/// <param name="zIndexMaxComp">Z index max comp.</param>
/// <param name="child">Child.</param>
/// <param name="zIndexMaxChild">Z index max child.</param>
public float calculateLayerDepthForChild(float zIndexMin, float zIndexMax, MainItemVO child, float zIndexMaxChild = 100)
{
if (zIndexMaxChild < zIndexMax)
{
zIndexMaxChild = zIndexMax * 10;
}
if (child.zIndex < zIndex)
{
child.zIndex = zIndex + 1;
}
var ourLayerDepth = calculateLayerDepth(zIndexMin, zIndexMax, null);
var childLayerDepth = child.calculateLayerDepth(zIndexMin, zIndexMax, null);
return(Mathf.clamp01(ourLayerDepth + childLayerDepth));
//return calculateLayerDepth( zIndexMin, zIndexMax, null ) - ( 1 - child.calculateLayerDepth( zIndexMin, zIndexMax, null ) );
}