Since Starling uses Stage3D for rendering, all rendered objects must be constructed * from triangles. A mesh stores the information of its triangles through VertexData and * IndexData structures. The default format stores position, color and texture coordinates * for each vertex.
* *How a mesh is rendered depends on its style. Per default, this is an instance
* of the MeshStyle base class; however, subclasses may extend its behavior
* to add support for color transformations, normal mapping, etc.
MeshStyle will be created
* for you. Note that the format of the vertex data will be matched to the
* given style right away. */
public function new(vertexData:VertexData, indexData:IndexData, style:MeshStyle=null)
{
super();
if (vertexData == null) throw new ArgumentError("VertexData must not be null");
if (indexData == null) throw new ArgumentError("IndexData must not be null");
__vertexData = vertexData;
__indexData = indexData;
setStyle(style, false);
}
/** @inheritDoc */
override public function dispose():Void
{
__vertexData.clear();
__indexData.clear();
super.dispose();
}
/** @inheritDoc */
override public function hitTest(localPoint:Point):DisplayObject
{
if (!visible || !touchable || !hitTestMask(localPoint)) return null;
else return MeshUtil.containsPoint(__vertexData, __indexData, localPoint) ? this : null;
}
/** @inheritDoc */
override public function getBounds(targetSpace:DisplayObject, out:Rectangle=null):Rectangle
{
return MeshUtil.calculateBounds(__vertexData, this, targetSpace, out);
}
/** @inheritDoc */
override public function render(painter:Painter):Void
{
if (__pixelSnapping)
MatrixUtil.snapToPixels(painter.state.modelviewMatrix, painter.pixelSize);
painter.batchMesh(this);
}
/** Sets the style that is used to render the mesh. Styles (which are always subclasses of
* MeshStyle) provide a means to completely modify the way a mesh is rendered.
* For example, they may add support for color transformations or normal mapping.
*
* When assigning a new style, the vertex format will be changed to fit it.
* Do not use the same style instance on multiple objects! Instead, make use of
* style.clone() to assign an identical style to multiple meshes.
null, the default
* style will be created.
* @param mergeWithPredecessor if enabled, all attributes of the previous style will be
* be copied to the new one, if possible.
* @see #defaultStyle
* @see #defaultStyleFactory
*/
public function setStyle(meshStyle:MeshStyle=null, mergeWithPredecessor:Bool=true):Void
{
if (meshStyle == null) meshStyle = createDefaultStyle(this);
else if (meshStyle == __style) return;
else if (meshStyle.target != null) meshStyle.target.setStyle();
if (__style != null)
{
if (mergeWithPredecessor) meshStyle.copyFrom(__style);
__style.setTarget();
}
__style = meshStyle;
__style.setTarget(this, __vertexData, __indexData);
setRequiresRedraw();
}
/** Creates a new instance of the current default MeshStyle. Internally, this method
* calls either the defaultStyleFactory or (if no factory has been assigned)
* instantiates defaultStyle.
*/
public static function createDefaultStyle(instance:Mesh=null):MeshStyle
{
var meshStyle:MeshStyle = null;
if (sDefaultStyleFactory != null)
{
if (instance == null) meshStyle = sDefaultStyleFactory();
else meshStyle = sDefaultStyleFactory(instance);
}
if (meshStyle == null)
meshStyle = Type.createInstance(sDefaultStyle, []);
return meshStyle;
}
/** This method is called whenever the mesh's vertex data was changed.
* The base implementation simply forwards to setRequiresRedraw. */
public function setVertexDataChanged():Void
{
setRequiresRedraw();
}
/** This method is called whenever the mesh's index data was changed.
* The base implementation simply forwards to setRequiresRedraw. */
public function setIndexDataChanged():Void
{
setRequiresRedraw();
}
// vertex manipulation
/** The position of the vertex at the specified index, in the mesh's local coordinate
* system.
*
* Only modify the position of a vertex if you know exactly what you're doing, as
* some classes might not work correctly when their vertices are moved. E.g. the
* Quad class expects its vertices to spawn up a perfectly rectangular
* area; some of its optimized methods won't work correctly if that premise is no longer
* fulfilled or the original bounds change.
setRequiresRedraw. */
private var vertexData(get, never):VertexData;
private function get_vertexData():VertexData { return __vertexData; }
/** The index data describing how the vertices are interconnected.
* Any change requires a call to setRequiresRedraw. */
private var indexData(get, never):IndexData;
private function get_indexData():IndexData { return __indexData; }
/** The style that is used to render the mesh. Styles (which are always subclasses of
* MeshStyle) provide a means to completely modify the way a mesh is rendered.
* For example, they may add support for color transformations or normal mapping.
* Beware: a style instance may only be used on one mesh at a time.
*
* @default MeshStyle
* @see #setStyle()
*/
public var style(get, set):MeshStyle;
private function get_style():MeshStyle { return __style; }
private function set_style(value:MeshStyle):MeshStyle
{
setStyle(value);
return value;
}
/** The texture that is mapped to the mesh (or null, if there is none). */
public var texture(get, set):Texture;
private function get_texture():Texture { return __style.texture; }
private function set_texture(value:Texture):Texture { return __style.texture = value; }
/** Changes the color of all vertices to the same value.
* The getter simply returns the color of the first vertex. */
public var color(get, set):UInt;
private function get_color():UInt { return __style.color; }
private function set_color(value:UInt):UInt { return __style.color = value; }
/** The smoothing filter that is used for the texture.
* @default bilinear */
public var textureSmoothing(get, set):String;
private function get_textureSmoothing():String { return __style.textureSmoothing; }
private function set_textureSmoothing(value:String):String { return __style.textureSmoothing = value; }
/** Indicates if pixels at the edges will be repeated or clamped. Only works for
* power-of-two textures; for a solution that works with all kinds of textures,
* see Image.tileGrid. @default false */
public var textureRepeat(get, set):Bool;
private function get_textureRepeat():Bool { return __style.textureRepeat; }
private function set_textureRepeat(value:Bool):Bool { return __style.textureRepeat = value; }
/** Controls whether or not the instance snaps to the nearest pixel. This can prevent the
* object from looking blurry when it's not exactly aligned with the pixels of the screen.
* @default false */
public var pixelSnapping(get, set):Bool;
private function get_pixelSnapping():Bool { return __pixelSnapping; }
private function set_pixelSnapping(value:Bool):Bool { return __pixelSnapping = value; }
/** The total number of vertices in the mesh. */
public var numVertices(get, never):Int;
private function get_numVertices():Int { return __vertexData.numVertices; }
/** The total number of indices referencing vertices. */
public var numIndices(get, never):Int;
private function get_numIndices():Int { return __indexData.numIndices; }
/** The total number of triangles in this mesh.
* (In other words: the number of indices divided by three.) */
public var numTriangles(get, never):Int;
private function get_numTriangles():Int { return __indexData.numTriangles; }
/** The format used to store the vertices. */
public var vertexFormat(get, never):VertexDataFormat;
private function get_vertexFormat():VertexDataFormat { return __style.vertexFormat; }
// static properties
/** The default style used for meshes if no specific style is provided. The default is
* starling.rendering.MeshStyle, and any assigned class must be a subclass
* of the same. */
public static var defaultStyle(get, set):ClassdefaultStyle
* property, this method allows plugging in custom logic and passing arguments to the
* constructor. Return null to fall back to the default behavior (i.e.
* to instantiate defaultStyle). The mesh-parameter is optional
* and may be omitted.
*
*