public void SetHole1(FAtlasElement holeElement,FAtlasElement toDigElement)
 {
     _elementHole1=holeElement;
     _elementToDig1=toDigElement;
     _hole1Offset=_elementHole1.uvTopLeft-_elementToDig1.uvTopLeft;
     needsApply = true;
 }

 public void SetHole0(FAtlasElement holeElement,FAtlasElement toDigElement)
 {
     _elementHole0=holeElement;
     _elementToDig0=toDigElement;
     _hole0Offset=_elementHole0.uvTopLeft-_elementToDig0.uvTopLeft;
     needsApply = true;
 }

    protected void Init(FFacetType facetType, FAtlasElement element, int numberOfFacetsNeeded)
    {
        _element = element;

        base.Init(facetType,_element.atlas,numberOfFacetsNeeded);

        HandleElementChanged();
    }

 public void UpdateToDig0(FAtlasElement toDigElement)
 {
     if (_elementHole0!=null) {
         _elementToDig0=toDigElement;
         _hole0Offset=_elementHole0.uvTopLeft-_elementToDig0.uvTopLeft;
         needsApply = true;
     }
 }

    public FSplitSprite(FAtlasElement element)
        : base()
    {
        Init(FFacetType.Quad, element,0); //this will call HandleElementChanged(), which will call SetupSlices();

        _isAlphaDirty = true;

        UpdateLocalVertices();
    }

    public FFont(string name, FAtlasElement element, string configPath, FTextParams fontTextParams)
    {
        _name = name;
        _element = element;
        _configPath = configPath;
        _fontTextParams = fontTextParams;

        LoadAndParseConfigFile();
    }

 public WTAnimation(string name, FAtlasElement[] spriteFrames, float minFrameDuration, float maxFrameDuration, bool isLooping)
 {
     this.spriteFrames = spriteFrames;
     this.name = name;
     this.isLooping = isLooping;
     this.minFrameDuration = minFrameDuration;
     this.maxFrameDuration = maxFrameDuration;
     this.frameDuration = this.minFrameDuration;
 }

	public FSprite (FAtlasElement element) : base()
	{
		_localVertices = new Vector2[4];
		
		Init(FFacetType.Quad, element,1);
		
		_isAlphaDirty = true;
		
		UpdateLocalVertices();
	}

	protected void Init(FMeshData meshData, FAtlasElement element)
	{
		_meshData = meshData;
		_previousMeshDataVersion = _meshData.version;
		
		Init(_meshData.facetType, element,meshData.facets.Count);

		_isMeshDirty = true;
		_isAlphaDirty = true;
	}

 //It's recommended to use myAtlas.CreateElement() instead of this
 public void AddElement(FAtlasElement element)
 {
     if(_allElementsByName.ContainsKey(element.name))
     {
         throw new FutileException("Duplicate element name '" + element.name +"' found! All element names must be unique!");
     }
     else
     {
         _allElementsByName.Add (element.name, element);
     }
 }

    public FFont(string name, FAtlasElement element, string configPath, float offsetX, float offsetY, FTextParams textParams)
    {
        _name = name;
        _element = element;
        _configPath = configPath;
        _textParams = textParams;
        _offsetX = offsetX;
        _offsetY = offsetY;

        LoadAndParseConfigFile();
    }

    public FShadowSprite(FAtlasElement element, float shadowOffsetX, float shadowOffsetY)
        : base()
    {
        _shadowOffsetX = shadowOffsetX;
        _shadowOffsetY = shadowOffsetY;

        Init(FFacetType.Quad, element,0); //this will call HandleElementChanged(), which will call SetupSlices();

        _isAlphaDirty = true;

        UpdateLocalVertices();
    }

    public FractalElement(float size,bool root,int maxChainCount,FAtlasElement atlasElement=null,float spriteScaleRatio=1f)
    {
        _size=size;
        _root=root;
        _spriteScaleRatio=spriteScaleRatio;
        _maxChaincount=maxChainCount;
        _atlasElement=atlasElement;
        if (_atlasElement==null) {
            _atlasElement=Futile.atlasManager.GetElementWithName("Futile_White");
        }
        _elements=new List<FractalElement>();

        Build();
    }

        public CircularParticleSystem(FAtlasElement element, float innerRadius, float lifetime, float speed, float particlesPerSecond, int maxParticleCount)
            : base(maxParticleCount)
        {
            this.element = element;
            this.innerRadius = innerRadius;
            this.lifetime = lifetime;
            this.speed = speed;
            this.timePerParticle = 1.0f / particlesPerSecond;

            timeUntilNextParticle = timePerParticle;

            particleDef = new FParticleDefinition (element);
            particleDef.endColor = Color.white.CloneWithNewAlpha (0.0f);

            ListenForAfterUpdate (HandleUpdate);
        }

	public FSliceSprite (FAtlasElement element, float width, float height, float insetTop, float insetRight, float insetBottom, float insetLeft) : base()
	{
		_width = width;
		_height = height;
		
		_insetTop = insetTop;
		_insetRight = insetRight;
		_insetBottom = insetBottom;
		_insetLeft = insetLeft;
		
		Init(FFacetType.Quad, element,0); //this will call HandleElementChanged(), which will call SetupSlices();
		
		_isAlphaDirty = true;
		
		UpdateLocalVertices();
	}

    public BorderBox(float width, float height, float borderThickness, FAtlasElement element)
        : base(FFacetType.Quad, element)
    {
        _width = width;
        _height = height;
        _borderThickness = borderThickness;

        _innerVertices = new FMeshVertex[]{new FMeshVertex(0,0,0,1),new FMeshVertex(0,0,1,1),new FMeshVertex(0,0,1,0),new FMeshVertex(0,0,0,0)};
        _outerVertices = new FMeshVertex[]{new FMeshVertex(0,0,0,1),new FMeshVertex(0,0,1,1),new FMeshVertex(0,0,1,0),new FMeshVertex(0,0,0,0)};

        _meshData.AddQuad(_outerVertices[0],_outerVertices[1],_innerVertices[1],_innerVertices[0]);
        _meshData.AddQuad(_outerVertices[1],_outerVertices[2],_innerVertices[2],_innerVertices[1]);
        _meshData.AddQuad(_outerVertices[2],_outerVertices[3],_innerVertices[3],_innerVertices[2]);
        _meshData.AddQuad(_outerVertices[3],_outerVertices[0],_innerVertices[0],_innerVertices[3]);

        _meshData.AddQuad().SetColorForAllVertices(new Color(1,1,1,0.5f));

        UpdateMesh();
    }

	//a simple tile map that takes an array of elements and renders it
	//note: the elements must all belong to the same atlas
	//note: elements.Length should equal cols*rows

	public FSimpleTileMap (FAtlasElement[] elements, int cols, int rows, float tileWidth, float tileHeight) : base()
	{
		_elements = elements;

		_cols = cols;
		_rows = rows;

		_tileWidth = tileWidth;
		_tileHeight = tileHeight;

		if(_elements.Length != _cols*_rows)
		{
			throw new FutileException("FSimpleTileMap - the number of elements does not match the number of rows and columns. It should be cols*rows = elements.Length");
		}
		
		Init(new FMeshData(FFacetType.Quad), _elements[0].atlas.fullElement);

		UpdateMesh();
	}

	//public bool isRotated;
	
	public FAtlasElement Clone()
	{
		FAtlasElement element = new FAtlasElement();
		
		element.name = name;
		
		element.indexInAtlas = indexInAtlas;
		
		element.atlas = atlas;
		element.atlasIndex = atlasIndex;
		
		element.uvRect = uvRect;
		element.uvTopLeft = uvTopLeft;
		element.uvTopRight = uvTopRight;
		element.uvBottomRight = uvBottomRight;
		element.uvBottomLeft = uvBottomLeft;
		
		element.sourceRect = sourceRect;
		element.sourceSize = sourceSize;
		element.isTrimmed = isTrimmed;
		
		return element;
	}

	public FAtlasElement CreateNamedElement (string elementName, float leftX, float bottomY, float pixelWidth, float pixelHeight)
	{
		FAtlasElement element = _elementsByName[elementName];

		if(element == null) //it doesn't exist, so create it (if it does exist we just update it)
		{
			element = new FAtlasElement();
			element.name = elementName;
			element.atlas = this;
			element.atlasIndex = _index;
			
			_elementsByName.Add(elementName,element);
			_elements.Add(element);
			Futile.atlasManager.AddElement(element);
		}

		UpdateElement(element,leftX,bottomY,pixelWidth,pixelHeight);

		return element;
	}

	public FAtlasElement CreateUnnamedElement (float leftX, float bottomY, float pixelWidth, float pixelHeight)
	{
		//note that this element has no name, so it is not stored in the atlas or atlasmanager

		FAtlasElement element = new FAtlasElement();

		element.atlas = this;
		element.atlasIndex = _index;

		UpdateElement(element,leftX,bottomY,pixelWidth,pixelHeight);

		return element;
	}