IEnumerator DoSpawnAll(SpriteShape spriteShape, float delayPerSpawn)
{
var wait = new WaitForSeconds(delayPerSpawn);
mParms[Rock.parmSpriteShape] = spriteShape;
mParms[Rock.parmDir] = (Vector2)spawnPoint.up;
for (int i = 0; i < capacity; i++)
{
mPool.Spawn(name, "", null, spawnPoint.position, mParms);
yield return(wait);
}
}
public static void CreateNewSpriteShape()
{
SpriteShape newSpriteShape = SpriteShapeEditorUtility.CreateSpriteShapeAsset();
newSpriteShape.angleRanges.Add(CreateAngleRange(-22.5f, 22.5f, 7));
newSpriteShape.angleRanges.Add(CreateAngleRange(22.5f, 67.5f, 6));
newSpriteShape.angleRanges.Add(CreateAngleRange(67.5f, 112.5f, 4));
newSpriteShape.angleRanges.Add(CreateAngleRange(112.5f, 157.5f, 2));
newSpriteShape.angleRanges.Add(CreateAngleRange(157.5f, 202.5f, 8));
newSpriteShape.angleRanges.Add(CreateAngleRange(-157.5f, -112.5f, 1));
newSpriteShape.angleRanges.Add(CreateAngleRange(-112.5f, -67.5f, 3));
newSpriteShape.angleRanges.Add(CreateAngleRange(-67.5f, -22.5f, 5));
}
static GameObject CreateDragGO(SpriteShape spriteShape, Vector3 position)
{
SpriteShapeController spriteShapeController = SpriteShapeEditorUtility.CreateSpriteShapeController();
GameObject gameObject = spriteShapeController.gameObject;
gameObject.transform.position = position;
gameObject.hideFlags = HideFlags.HideAndDontSave;
spriteShapeController.spriteShape = spriteShape;
SpriteShapeEditorUtility.SetShapeFromAsset(spriteShapeController);
return(gameObject);
}
protected override void OnReadyForInitGLShaderProgram()
{
SvgRenderVx svgRenderVx = SvgRenderVxLoader.CreateSvgRenderVxFromFile("d:\\WImageTest\\lion.svg");
lionShape = new SpriteShape(svgRenderVx);
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionShape.ApplyTransform(aff);
}
static void DrawLion(Painter p, SpriteShape shape)
{
shape.Paint(p);
//int j = shape.NumPaths;
//int[] pathList = shape.PathIndexList;
//Color[] colors = shape.Colors;
//for (int i = 0; i < j; ++i)
//{
// p.FillColor = colors[i];
// p.Fill(new VertexStoreSnap(myvxs, pathList[i]));
//}
}
public perspective_application()
{
lionShape = new SpriteShape();
lionShape.ParseLion();
quadPolygonControl = new PixelFarm.Agg.UI.PolygonEditWidget(4, 5.0);
quadPolygonControl.SetXN(0, lionShape.Bounds.Left);
quadPolygonControl.SetYN(0, lionShape.Bounds.Top);
quadPolygonControl.SetXN(1, lionShape.Bounds.Right);
quadPolygonControl.SetYN(1, lionShape.Bounds.Top);
quadPolygonControl.SetXN(2, lionShape.Bounds.Right);
quadPolygonControl.SetYN(2, lionShape.Bounds.Bottom);
quadPolygonControl.SetXN(3, lionShape.Bounds.Left);
quadPolygonControl.SetYN(3, lionShape.Bounds.Bottom);
}
public perspective_application()
{
lionShape = new SpriteShape(SvgRenderVxLoader.CreateSvgRenderVxFromFile(@"Samples\lion.svg"));
quadPolygonControl = new PixelFarm.Agg.UI.PolygonEditWidget(4, 5.0);
quadPolygonControl.SetXN(0, lionShape.Bounds.Left);
quadPolygonControl.SetYN(0, lionShape.Bounds.Top);
quadPolygonControl.SetXN(1, lionShape.Bounds.Right);
quadPolygonControl.SetYN(1, lionShape.Bounds.Top);
quadPolygonControl.SetXN(2, lionShape.Bounds.Right);
quadPolygonControl.SetYN(2, lionShape.Bounds.Bottom);
quadPolygonControl.SetXN(3, lionShape.Bounds.Left);
quadPolygonControl.SetYN(3, lionShape.Bounds.Bottom);
}
private void _quadControl_ShapeUpdated(QuadWidgetControl sender, EventArgs arg)
{
//update shape of sprite
//transform from original lionBounds to quadPolygon
Quad2f quadCorners = _quadControl.GetQuadCorners();
_quadCorners[0] = quadCorners.left_top_x;
_quadCorners[1] = quadCorners.left_top_y;
_quadCorners[2] = quadCorners.right_top_x;
_quadCorners[3] = quadCorners.right_top_y;
_quadCorners[4] = quadCorners.right_bottom_x;
_quadCorners[5] = quadCorners.right_bottom_y;
_quadCorners[6] = quadCorners.left_bottom_x;
_quadCorners[7] = quadCorners.left_bottom_y;
//this is bilinear transformation
if (_useBilinear)
{
Bilinear txBilinear = Bilinear.RectToQuad(
_lionBounds.Left,
_lionBounds.Top,
_lionBounds.Right,
_lionBounds.Bottom,
_quadCorners);
if (txBilinear.IsValid)
{
SpriteShape spriteShape = _mySprite.GetSpriteShape();
spriteShape.ResetTransform();
spriteShape.ApplyTransform(txBilinear);
}
}
else
{
Perspective perspective = new Perspective(
_lionBounds.Left,
_lionBounds.Top,
_lionBounds.Right,
_lionBounds.Bottom,
_quadCorners);
if (perspective.IsValid)
{
SpriteShape spriteShape = _mySprite.GetSpriteShape();
spriteShape.ResetTransform();
spriteShape.ApplyTransform(perspective);
}
}
}
public override void Init()
{
VgVisualElement renderVx = VgVisualDocHelper.CreateVgVisualDocFromFile(@"Samples\lion.svg").VgRootElem;
var spriteShape = new SpriteShape(renderVx);
_testSprite = new MyTestSprite(spriteShape);
//lionFill.AutoFlipY = true;
_currentTx = PixelFarm.CpuBlit.VertexProcessing.Affine.NewMatix(
VertexProcessing.AffinePlan.RotateDeg(30),
VertexProcessing.AffinePlan.Scale(2)
);
}
public static GameObject Create(SpriteShape shape, Vector3 position, SceneView sceneView)
{
string name = string.IsNullOrEmpty(shape.name) ? "New SpriteShapeController" : shape.name;
name = GameObjectUtility.GetUniqueNameForSibling(null, name);
GameObject go = new GameObject(name);
SpriteShapeController shapeController = go.AddComponent <SpriteShapeController>();
shapeController.spriteShape = shape;
go.transform.position = position;
go.hideFlags = HideFlags.HideAndDontSave;
return(go);
}
protected override void OnInitGLProgram(object sender, EventArgs args)
{
int max = Math.Max(this.Width, this.Height);
canvas2d = CreateCanvasGL2d(max, max);
lionShape = new SpriteShape();
lionShape.ParseLion();
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionVxs = new VertexStore();
aff.TransformToVxs(lionShape.Path.Vxs, lionVxs);
painter = new GLCanvasPainter(canvas2d, max, max);
}
public static SpriteShapeController CreateSpriteShapeController(SpriteShape shape)
{
var objName = "New SpriteShapeController";
GameObject gameObject = new GameObject(objName, typeof(SpriteShapeController));
SpriteShapeController spriteShapeController = gameObject.GetComponent <SpriteShapeController>();
spriteShapeController.spline.Clear();
if (shape != null)
{
objName = shape.name;
}
gameObject.name = GameObjectUtility.GetUniqueNameForSibling(gameObject.transform.parent, objName);
SpriteShapeEditorAnalytics.instance.eventBus.spriteShapeRendererEvent.Invoke(gameObject.GetComponent <SpriteShapeRenderer>());
return(spriteShapeController);
}
public perspective_application()
{
_lionShape = new SpriteShape(PaintLab.Svg.VgVisualDocHelper.CreateVgVisualDocFromFile(@"Samples\lion.svg").VgRootElem);
_lionFill = new MyTestSprite(_lionShape);
_quadPolygonControl = new PixelFarm.CpuBlit.UI.PolygonEditWidget(4, 5.0);
_quadPolygonControl.SetXN(0, _lionShape.Bounds.Left);
_quadPolygonControl.SetYN(0, _lionShape.Bounds.Top);
_quadPolygonControl.SetXN(1, _lionShape.Bounds.Right);
_quadPolygonControl.SetYN(1, _lionShape.Bounds.Top);
_quadPolygonControl.SetXN(2, _lionShape.Bounds.Right);
_quadPolygonControl.SetYN(2, _lionShape.Bounds.Bottom);
_quadPolygonControl.SetXN(3, _lionShape.Bounds.Left);
_quadPolygonControl.SetYN(3, _lionShape.Bounds.Bottom);
}
public FilterFxDemo()
{
VgVisualElement renderVx = VgVisualDocHelper.CreateVgVisualDocFromFile(@"Samples\lion.svg").VgRootElem;
var spriteShape = new SpriteShape(renderVx);
_testSprite = new MyTestSprite(spriteShape);
//--------------
//m_rbuf2 = new ReferenceImage();
_shape_bounds = new RectD();
_shadow_ctrl = new PolygonEditWidget(4);
this.FlattenCurveChecked = true;
this.FilterMethod = FilterMethod.None;
this.BlurRadius = 15;
//
}
public void Init2(CanvasGL2d canvas2d)
{
int max = 800;
this.canvas2d = canvas2d;
lionShape = new SpriteShape();
lionShape.ParseLion();
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionVxs = new VertexStore();
aff.TransformToVxs(lionShape.Path.Vxs, lionVxs);
painter = new GLCanvasPainter(canvas2d, max, max);
SetPrinter(painter);
}
protected override void OnReadyForInitGLShaderProgram()
{
PaintLab.Svg.VgVisualDoc vgVisualDoc = PaintLab.Svg.VgVisualDocHelper.CreateVgVisualDocFromFile("Samples/lion.svg");
_lionShape = new SpriteShape(vgVisualDoc.VgRootElem);
var lionBounds = _lionShape.Bounds;
//-------------
_memBmp = new MemBitmap((int)lionBounds.Width, (int)lionBounds.Height);
_aggPainter = AggPainter.Create(_memBmp);
DrawLion(_aggPainter, _lionShape);
//convert affImage to texture
_glBmp = DemoHelper.LoadTexture(_memBmp);
}
protected override void OnReadyForInitGLShaderProgram()
{
lionShape = new SpriteShape();
lionShape.ParseLion();
RectD lionBounds = lionShape.Bounds;
//-------------
aggImage = new ActualImage((int)lionBounds.Width, (int)lionBounds.Height, PixelFarm.Agg.PixelFormat.ARGB32);
_aggsx = new AggRenderSurface(aggImage);
aggPainter = new AggPainter(_aggsx);
DrawLion(aggPainter, lionShape, lionShape.Vxs);
//convert affImage to texture
glBmp = DemoHelper.LoadTexture(aggImage);
}
private List <ShapeAngleRange> GetAngleRangeSorted(SpriteShape ss)
{
List <ShapeAngleRange> angleRanges = new List <ShapeAngleRange>();
int i = 0;
foreach (var angleRange in ss.angleRanges)
{
ShapeAngleRange sar = new ShapeAngleRange()
{
start = angleRange.start, end = angleRange.end, order = angleRange.order, index = i
};
angleRanges.Add(sar);
i++;
}
angleRanges.Sort((a, b) => a.order.CompareTo(b.order));
return(angleRanges);
}
protected override void OnReadyForInitGLShaderProgram()
{
string sampleFile = "Samples/lion.svg";
//string sampleFile = "Samples/tiger_whiskers.svg";
//string sampleFile = "Samples/tiger002.svg";
//string sampleFile = "Samples/tiger_wrinkles.svg";
VgVisualElement vgVisElem = VgVisualDocHelper.CreateVgVisualDocFromFile(sampleFile).VgRootElem;
_spriteShape = new SpriteShape(vgVisElem);
//flip this lion vertically
//PixelFarm.CpuBlit.VertexProcessing.Affine aff = PixelFarm.CpuBlit.VertexProcessing.Affine.NewMatix(
// PixelFarm.CpuBlit.VertexProcessing.AffinePlan.Scale(1, -1),
// PixelFarm.CpuBlit.VertexProcessing.AffinePlan.Translate(0, 600));
//_lionShape.ApplyTransform(aff);
}
protected override void OnReadyForInitGLShaderProgram()
{
int max = Math.Max(this.Width, this.Height);
lionShape = new SpriteShape();
lionShape.ParseLion();
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionVxs = new VertexStore();
aff.TransformToVxs(lionShape.Vxs, lionVxs);
//convert lion vxs to renderVx
////-------------
////version 1:
//int j = lionShape.NumPaths;
//int[] pathList = lionShape.PathIndexList;
//for (int i = 0; i < j; ++i)
//{
// lionRenderVxList.Add(painter.CreateRenderVx(new VertexStoreSnap(lionVxs, pathList[i])));
//}
////-------------
//version 2:
{
tmpDrawVersion = 2;
MultiPartPolygon mutiPartPolygon = new MultiPartPolygon();
int j = lionShape.NumPaths;
int[] pathList = lionShape.PathIndexList;
Color[] colors = lionShape.Colors;
for (int i = 0; i < j; ++i)
{
//from lionvxs extract each part
//fetch data and add to multipart polygon
//if (i != 4) continue;
//if (i > 1)
//{
// break;
//}
mutiPartPolygon.AddVertexSnap(new VertexStoreSnap(lionVxs, pathList[i]));
}
//then create single render vx
this.multipartTessResult = painter.CreateMultiPartTessResult(mutiPartPolygon);
//create render vx for the multipart test result
}
}
public void OnEnable()
{
m_PreviewAngle = SessionState.GetFloat("SpriteShape/PreviewAngle/" + target.GetInstanceID(), m_PreviewAngle);
m_SpriteShape = target as SpriteShape;
m_FillTextureProp = this.serializedObject.FindProperty("m_FillTexture");
m_UseSpriteBordersProp = serializedObject.FindProperty("m_UseSpriteBorders");
m_AngleRangesProp = this.serializedObject.FindProperty("m_Angles");
m_CornerSpritesProp = this.serializedObject.FindProperty("m_CornerSprites");
m_FillOffsetProp = this.serializedObject.FindProperty("m_FillOffset");
selectedIndex = SpriteShapeEditorUtility.GetRangeIndexFromAngle(angleRanges, m_PreviewAngle);
SetupAngleRangeController();
Undo.undoRedoPerformed += UndoRedoPerformed;
}
protected override void OnReadyForInitGLShaderProgram()
{
var _svgRenderVx = PixelFarm.Agg.SvgRenderVxLoader.CreateSvgRenderVxFromFile("Samples/lion.svg");
lionShape = new SpriteShape(_svgRenderVx);
RectD lionBounds = lionShape.Bounds;
//-------------
aggImage = new ActualImage((int)lionBounds.Width, (int)lionBounds.Height);
_aggsx = new AggRenderSurface(aggImage);
aggPainter = new AggPainter(_aggsx);
DrawLion(aggPainter, lionShape);
//convert affImage to texture
glBmp = DemoHelper.LoadTexture(aggImage);
}
protected override void OnInitGLProgram(object sender, EventArgs args)
{
lionShape = new SpriteShape();
lionShape.ParseLion();
RectD lionBounds = lionShape.Bounds;
//-------------
aggImage = new ActualImage((int)lionBounds.Width, (int)lionBounds.Height, PixelFarm.Agg.PixelFormat.ARGB32);
imgGfx2d = new ImageGraphics2D(aggImage);
aggPainter = new AggCanvasPainter(imgGfx2d);
DrawLion(aggPainter, lionShape, lionShape.Path.Vxs);
//convert affImage to texture
glBmp = LoadTexture(aggImage);
int max = Math.Max(this.Width, this.Height);
canvas2d = PixelFarm.Drawing.GLES2.GLES2Platform.CreateCanvasGL2d(max, max);
//-------------------------
painter = new GLCanvasPainter(canvas2d, max, max);
}
public void SwitchSpriteShape()
{
stockedShape = currentPlatform.GetComponent <SpriteShapeController>().spriteShape;
if (stockedShape.name.Length - "LinearPlatform".Length > 0)
{
if (stockedShape.name.Substring(stockedShape.name.Length - "LinearPlatform".Length) == "LinearPlatform")
{
currentPlatform.GetComponent <SpriteShapeController>().spriteShape = thornsLinearShape;
}
else
{
currentPlatform.GetComponent <SpriteShapeController>().spriteShape = thornsShape;
}
}
else
{
currentPlatform.GetComponent <SpriteShapeController>().spriteShape = thornsShape;
}
currentPlatform.tag = "Thorns";
Invoke("Infest", timeBetweenEachInfest);
}
void M8.IPoolSpawn.OnSpawned(M8.GenericParams parms)
{
if (!mPoolData)
{
mPoolData = GetComponent <M8.PoolDataController>();
}
SpriteShape spriteShape = null;
Vector2 dir = Vector2.zero;
if (parms != null)
{
if (parms.ContainsKey(parmSpriteShape))
{
spriteShape = parms.GetValue <SpriteShape>(parmSpriteShape);
}
if (parms.ContainsKey(parmDir))
{
dir = parms.GetValue <Vector2>(parmDir);
}
}
if (spriteShape)
{
spriteShapeCtrl.spriteShape = spriteShape;
}
transform.localEulerAngles = new Vector3(0f, 0f, Random.Range(0f, 360f));
spriteShapeCtrl.enabled = true;
mBody.simulated = true;
dir = M8.MathUtil.RotateAngle(dir, dirAngleRange.random);
mBody.AddForce(dir * impulseRange.random, ForceMode2D.Impulse);
spriteShapeCtrl.spriteShapeRenderer.color = mDefaultColor;
StartCoroutine(DoAlive());
}
public alpha_mask2_application()
{
lionShape = new SpriteShape(SvgRenderVxLoader.CreateSvgRenderVxFromFile("Samples\arrow2.svg"));
this.Width = 800;
this.Height = 600;
//AnchorAll();
//alphaMaskImageBuffer = new ReferenceImage();
#if USE_CLIPPING_ALPHA_MASK
//alphaMask = new AlphaMaskByteClipped(alphaMaskImageBuffer, 1, 0);
#else
//alphaMask = new AlphaMaskByteUnclipped(alphaMaskImageBuffer, 1, 0);
#endif
//numMasksSlider = new UI.Slider(5, 5, 150, 12);
//sliderValue = 0.0;
//AddChild(numMasksSlider);
//numMasksSlider.SetRange(5, 100);
//numMasksSlider.Value = 10;
//numMasksSlider.Text = "N={0:F3}";
//numMasksSlider.OriginRelativeParent = Vector2.Zero;
}
public static void SetShapeFromAsset(SpriteShapeController spriteShapeController)
{
SpriteShape spriteShape = spriteShapeController.spriteShape;
if (!spriteShape)
{
SpriteShapeEditorUtility.SetToSquare(spriteShapeController);
return;
}
if (spriteShape.angleRanges.Count == 1 && spriteShape.angleRanges[0].end - spriteShape.angleRanges[0].start == 360f)
{
SpriteShapeEditorUtility.SetToLine(spriteShapeController);
}
else if (spriteShape.angleRanges.Count < 8)
{
SpriteShapeEditorUtility.SetToSquare(spriteShapeController);
}
else
{
SpriteShapeEditorUtility.SetToOctogon(spriteShapeController);
}
}
public IEnumerator Spawn(SpriteShape spriteShape, float delay)
{
layerSpriteCtrl.spriteShape = spriteShape;
layerSpriteCtrl.gameObject.SetActive(true);
var layerClr = layerSpriteCtrl.spriteShapeRenderer.color;
layerClr.a = 0f;
layerSpriteCtrl.spriteShapeRenderer.color = layerClr;
isSpawning = true;
float rockSpawnDelay = delay / spawner.capacity;
spawner.SpawnAll(spriteShape, rockSpawnDelay);
if (fadeInStartDelay > 0f)
{
yield return(new WaitForSeconds(fadeInStartDelay));
}
var curTime = 0f;
while (isSpawning && curTime < delay)
{
yield return(null);
curTime += Time.deltaTime;
var t = Mathf.Clamp01(curTime / delay);
layerClr.a = t;
layerSpriteCtrl.spriteShapeRenderer.color = layerClr;
}
isSpawning = false;
}
void TestLoadLionFromBinaryFile()
{
System.Diagnostics.Debugger.Break();
//test load raw buffer
using (var fs = new System.IO.FileStream("..\\lion_stream.bin", System.IO.FileMode.Open))
{
var reader = new System.IO.BinaryReader(fs);
var lionShape2 = new PixelFarm.Agg.SpriteShape();
PixelFarm.Agg.VertexSource.PathWriter path;
PixelFarm.Agg.ColorRGBA[] colors;
int[] pathIndexList;
//1. path and command
PixelFarm.Agg.VertexSource.dbugVertexSourceIO.ReadPathDataFromStream(
reader, out path
);
//2. colors
PixelFarm.Agg.VertexSource.dbugVertexSourceIO.ReadColorDataFromStream(
reader, out colors
);
//3. path indice
int npaths;
PixelFarm.Agg.VertexSource.dbugVertexSourceIO.ReadPathIndexListFromStream(
reader, out npaths, out pathIndexList
);
//------------------------------
SpriteShape.UnsafeDirectSetData(lionShape2,
npaths,
path, colors, pathIndexList);
//---------------------------------
fs.Close();
this.lionShape = lionShape2;
}
}
protected override void OnInitGLProgram(object sender, EventArgs args)
{
int max = Math.Max(this.Width, this.Height);
canvas2d = CreateCanvasGL2d(max, max);
lionShape = new SpriteShape();
lionShape.ParseLion();
//flip this lion vertically before use with openGL
PixelFarm.Agg.Transform.Affine aff = PixelFarm.Agg.Transform.Affine.NewMatix(
PixelFarm.Agg.Transform.AffinePlan.Scale(1, -1),
PixelFarm.Agg.Transform.AffinePlan.Translate(0, 600));
lionVxs = new VertexStore();
aff.TransformToVxs(lionShape.Path.Vxs, lionVxs);
painter = new GLCanvasPainter(canvas2d, max, max);
//convert lion vxs to renderVx
int j = lionShape.NumPaths;
int[] pathList = lionShape.PathIndexList;
for (int i = 0; i < j; ++i)
{
lionRenderVxList.Add(painter.CreateRenderVx(new VertexStoreSnap(lionVxs, pathList[i])));
}
}
/// <summary>
/// Overridable that is called to fill the combobox with data. The default implementation parses the enum values
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <param name="list"></param>
public virtual void FillListBox(SpriteShape shape, ITypeDescriptorContext context, IServiceProvider provider, object value, ListBox list)
{
string[] names = shape.EngineNode.GetStateNames();
string currentState = shape.EngineNode.GetCurrentState();
foreach (string name in names)
{
// Creates a clbItem that stores the name, the int value and the tooltip
int added = list.Items.Add(new ListItem(name, 0, ""));
if (name == currentState)
{
list.SelectedIndex = added;
}
}
}
private void CreateShape(System.Windows.Forms.DragEventArgs e)
{
Nullable<SpriteDropData> data = GetData(e);
if (data != null)
{
SpriteShape entity = new SpriteShape(data.Value._name);
entity.SpriteSheetFilename = data.Value._sheet;
entity.ShoeBoxData = data.Value._xml;
entity.SetHint(ShapeBase.HintFlags_e.RetainPositionAtCreation, true);
_dummyShape = entity;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="owner"></param>
/// <param name="fSize"></param>
public HotSpot2D(SpriteShape owner, float fSize)
: base(owner, null, VisionColors.White, HotSpotBase.PickType.Circle, fSize)
{
_fSize = fSize;
}
