@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/display/Graphics.ts

@@ -0,0 +1,609 @@
+
+import {
+	Graphics as AwayGraphics,
+	GraphicsPath as AwayGraphicsPath,
+	GraphicsStrokeStyle,
+	GraphicsFillStyle,
+	GraphicsEndFill as AwayGraphicsEndFill,
+	SolidFillStyle,
+	GradientFillStyle,
+	BitmapFillStyle,
+	IGraphicsData as AwayIGraphicsData,
+	CapsStyle as AwayCapsStyle,
+	JointStyle as AwayJointStyle,
+} from '@awayjs/graphics';
+import { ASObject, Float64Vector, Int32Vector } from '@awayfl/avm2';
+import { Debug, IAssetAdapter, Matrix as AwayMatrix } from '@awayjs/core';
+import { IContainer } from '@awayjs/view';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+
+import { ASArray, GenericVector, AXClass } from '@awayfl/avm2';
+import { BitmapData } from './BitmapData';
+import { LoaderInfo } from './LoaderInfo';
+import { SecurityDomain } from '../SecurityDomain';
+import { Matrix } from '../geom/Matrix';
+import { DisplayObject } from './DisplayObject';
+import { DisplayObjectContainer } from './DisplayObjectContainer';
+import { GraphicsStroke } from './GraphicsStroke';
+import { Sprite } from './Sprite';
+import { IGraphicsData } from './IGraphicsData';
+
+// AS3 caps and joints are strings, which @awayjs/graphics takes as numbers
+const CAPS_STYLES: Record<string, number> = {
+	none: AwayCapsStyle.NONE,
+	round: AwayCapsStyle.ROUND,
+	square: AwayCapsStyle.SQUARE
+};
+const JOINT_STYLES: Record<string, number> = {
+	round: AwayJointStyle.ROUND,
+	bevel: AwayJointStyle.BEVEL,
+	miter: AwayJointStyle.MITER
+};
+
+function styleName(styles: Record<string, number>, value: number): string {
+	for (const name in styles) {
+		if (styles[name] === value)
+			return name;
+	}
+	return 'round';
+}
+
+export class Graphics extends ASObject implements IAssetAdapter {
+
+	static axClass: typeof Graphics & AXClass;
+
+	public static currentAwayGraphics: AwayGraphics;
+
+	static classInitializer: any = function (this: any) {
+		// playerglobal.abcs Graphics is missing readGraphicsData, so linkClass never
+		// installs $BgreadGraphicsData. AS3 then calls a missing function (Error #1006).
+		const proto = this.dPrototype;
+		if (!proto)
+			return;
+		if (typeof proto.readGraphicsData === 'function')
+			proto.$BgreadGraphicsData = proto.readGraphicsData;
+	};
+
+	private _adaptee: AwayGraphics;
+
+	/**
+	 * True once clear() has given this wrapper its own private AwayGraphics.
+	 * Reset whenever the wrapper is retargeted to another AwayGraphics.
+	 */
+	private _ownsAdaptee: boolean = false;
+
+	constructor(adaptee: AwayGraphics = null) {
+		super();
+		this._setAdaptee(adaptee);
+	}
+
+	/**
+	 * Point this wrapper at a (possibly different) AwayGraphics. Called by the
+	 * owning Shape/Sprite when its AwayJS graphics object changes, so the AS3
+	 * Graphics instance stays the same for the lifetime of its display object.
+	 *
+	 * Note: this wrapper never stores a reference to its owning display object.
+	 * Timeline shape symbols share one AwayGraphics between all instances, and
+	 * that AwayGraphics lives as long as the symbol; anything reachable from it
+	 * (including its adapter) must not reach back into a display list.
+	 */
+	public _setAdaptee(adaptee: AwayGraphics): void {
+		const next = adaptee || new AwayGraphics();
+		const prev = this._adaptee;
+
+		if (prev === next)
+			return;
+
+		if (prev && prev._adapter === this)
+			prev.adapter = null;
+
+		this._adaptee = next;
+		this._ownsAdaptee = false;
+		next.adapter = this;
+	}
+
+	public dispose() {
+
+	}
+
+	public get adaptee(): AwayGraphics {
+		return this._adaptee;
+	}
+
+	public static FromData(data: any, loaderInfo: LoaderInfo): Graphics {
+		const graphics: Graphics = new (<SecurityDomain> this.sec).flash.display.Graphics();
+		return graphics;
+	}
+	/*
+	public getGraphicsData(): ShapeData {
+		return this._graphicsData;
+	}
+
+	public getUsedTextures(): BitmapData[] {
+		return this._textures;
+	}*/
+
+	public clear(): void {
+		this._detachSharedGraphics();
+		this.adaptee.clear();
+	}
+
+	/**
+	 * Copy-on-write: clear() on one instance must not wipe an AwayGraphics that
+	 * is also used by other instances (timeline shape symbols share one
+	 * AwayGraphics per symbol and keep it in the timeline graphics pool).
+	 * Give the owning display object a fresh, private AwayGraphics instead and
+	 * leave the shared original intact.
+	 */
+	private _detachSharedGraphics(): void {
+		const current = this._adaptee;
+		// An owned graphics can still pick up shared shapes and a
+		// sourceGraphics fallback through copyFrom(), so detach it again then.
+		if (!current || (this._ownsAdaptee && !current.sourceGraphics))
+			return;
+
+		let owners = 0;
+		current.forEachOwner(() => { owners++; });
+
+		const owner = this._findOwner();
+		const awayOwner: any = owner ? owner.adaptee : null;
+
+		if (!awayOwner) {
+			// Orphaned wrapper: never clear an AwayGraphics that something
+			// else still displays or that shares shapes with a copy source,
+			// otherwise clear in place.
+			if (owners > 0 || current.sourceGraphics)
+				this._takePrivateAdaptee(new AwayGraphics());
+			return;
+		}
+
+		// MovieClip graphics are per instance (copyTo clones are caught by
+		// sourceGraphics). An AwayJS Sprite owner may be a timeline shape holding
+		// the symbol's shared AwayGraphics even with a single owner, so it is
+		// detached once on its first clear(). Script-created Shape/Sprite also
+		// use an AwayJS Sprite adaptee, so they pay one extra AwayGraphics here.
+		const shared = owners > 1
+			|| !!current.sourceGraphics
+			|| !awayOwner.isAsset(AwayMovieClip);
+
+		if (!shared)
+			return;
+
+		const fresh = new AwayGraphics();
+		// The owner's graphics setter calls updateGraphics() on the AS3 owner,
+		// which retargets this same wrapper to the fresh graphics.
+		awayOwner.graphics = fresh;
+		this._takePrivateAdaptee(fresh);
+	}
+
+	private _takePrivateAdaptee(fresh: AwayGraphics): void {
+		this._setAdaptee(fresh);
+		this._ownsAdaptee = true;
+	}
+
+	/**
+	 * Sets a solid color and opacity as the fill for subsequent drawing commands.
+	 *
+	 * @see
+	 * http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/Graphics.html#beginFill%28%29
+	 * @param color
+	 * @param alpha While any Number is a valid input, the value is clamped to [0,1] and then scaled
+	 * to an integer in the interval [0,0xff].
+	 */
+	public beginFill(color: number /*uint*/, alpha: number = 1): void {
+		if (alpha < 0)
+			alpha = 0;
+		if (alpha > 1)
+			alpha = 1;
+		this.adaptee.beginFill(color, alpha);
+	}
+
+	public beginGradientFill(type: string, colors: ASArray, alphas: ASArray, ratios: ASArray,
+		matrix: Matrix = null, spreadMethod: string = 'pad',
+		interpolationMethod: string = 'rgb', focalPointRatio: number = 0): void {
+		this.adaptee.beginGradientFill(
+		<any>type, colors.value, alphas.value, ratios.value, matrix?.adaptee,
+			spreadMethod, interpolationMethod, focalPointRatio);
+	}
+
+	public beginBitmapFill(bitmap: BitmapData, matrix: Matrix = null,
+		repeat: boolean = true, smooth: boolean = false): void {
+		this.adaptee.beginBitmapFill(bitmap.adaptee, matrix?.adaptee, repeat, smooth);
+	}
+
+	public endFill(): void {
+		this.adaptee.endFill();
+	}
+
+	//    beginShaderFill(shader: flash.display.Shader, matrix: flash.geom.Matrix = null): void {
+	//      //shader = shader; matrix = matrix;
+	//      release || notImplemented("public flash.display.Graphics::beginShaderFill"); return;
+	//    }
+
+	public lineStyle(thickness: number, color: number /*uint*/ = 0, alpha: number = 1,
+		pixelHinting: boolean = false, scaleMode: string = 'normal', caps: string = null,
+		joints: string = null, miterLimit: number = 3): void {
+		// Flash clamps alpha to [0, 1] (AS2-era content commonly passes 0-100)
+		if (alpha < 0)
+			alpha = 0;
+		if (alpha > 1)
+			alpha = 1;
+		this.adaptee.lineStyle(
+			thickness, color, alpha, pixelHinting, <any>scaleMode,
+			// Flash uses round caps and joints when they're not given
+			CAPS_STYLES[caps] ?? AwayCapsStyle.ROUND,
+			JOINT_STYLES[joints] ?? AwayJointStyle.ROUND,
+			// and rounds miter limits outside [1, 255]
+			Math.min(255, Math.max(1, miterLimit)));
+	}
+
+	public lineGradientStyle(type: string, colors: ASArray, alphas: ASArray, ratios: ASArray,
+		matrix: Matrix = null, spreadMethod: string = 'pad',
+		interpolationMethod: string = 'rgb', focalPointRatio: number = 0): void {
+		this.adaptee.lineGradientStyle(
+			<any>type, colors.value, alphas.value, ratios.value,
+			matrix?.adaptee, spreadMethod, interpolationMethod, focalPointRatio);
+	}
+
+	public lineBitmapStyle(bitmap: BitmapData, matrix: Matrix = null,
+		repeat: boolean = true, smooth: boolean = false): void {
+		this.adaptee.lineBitmapStyle(bitmap.adaptee, matrix?.adaptee, repeat, smooth);
+	}
+
+	public drawRect(x: number, y: number, width: number, height: number): void {
+		this.adaptee.drawRect(x, y, width, height);
+	}
+
+	public drawRoundRect(x: number, y: number, width: number, height: number, ellipseWidth: number,
+		ellipseHeight: number): void {
+		this.adaptee.drawRoundRect(x, y, width, height, ellipseWidth, ellipseHeight);
+
+	}
+
+	public drawRoundRectComplex(x: number, y: number, width: number, height: number,
+		topLeftRadius: number, topRightRadius: number,
+		bottomLeftRadius: number,
+		bottomRightRadius: number): void {
+
+		this.adaptee.drawRoundRectComplex(
+			x, y, width, height, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius);
+
+	}
+
+	public drawCircle(x: number, y: number, radius: number): void {
+		this.adaptee.drawCircle(x, y, radius);
+	}
+
+	/**
+	 * Here x and y are the top-left coordinates of the bounding box of the
+	 * ellipse not the center as is the case for circles.
+	 */
+	public drawEllipse(x: number, y: number, width: number, height: number): void {
+		this.adaptee.drawEllipse(x, y, width, height);
+	}
+
+	public moveTo(x: number, y: number): void {
+		this.adaptee.moveTo(x, y);
+	}
+
+	public lineTo(x: number, y: number): void {
+		this.adaptee.lineTo(x, y);
+	}
+
+	public curveTo(controlX: number, controlY: number, anchorX: number, anchorY: number): void {
+		this.adaptee.curveTo(controlX, controlY, anchorX, anchorY);
+	}
+
+	public cubicCurveTo(controlX1: number, controlY1: number, controlX2: number, controlY2: number,
+		anchorX: number, anchorY: number): void {
+		this.adaptee.cubicCurveTo(controlX1, controlY1, controlX2, controlY2, anchorX, anchorY);
+	}
+
+	public copyFrom(sourceGraphics: Graphics): void {
+		this.adaptee.copyFrom(sourceGraphics.adaptee);
+	}
+
+	public drawPath(commands: Int32Vector, data: Float64Vector, winding: string = 'evenOdd'): void {
+		const cmdArr = commands._view();
+		const dataArr = data._view();
+		if (!cmdArr.length || !dataArr.length)
+			return;
+		//@ts-ignore
+		this.adaptee.drawPath(cmdArr, dataArr, winding);
+	}
+
+	public drawTriangles(vertices: Float64Vector, indices: Int32Vector = null,
+		uvtData: Int32Vector = null, culling: string = 'none'): void {
+		// @todo
+		Debug.throwPIR('playerglobals/display/Graphics', 'drawTriangles', '');
+	}
+
+	public drawGraphicsData(graphicsData: GenericVector): void {
+		if (!graphicsData)
+			return;
+
+		const len = graphicsData.length | 0;
+		for (let i = 0; i < len; i++) {
+			const item = graphicsData.axGetNumericProperty(i);
+			if (item)
+				this._drawGraphicsDataItem(item);
+		}
+	}
+
+	public readGraphicsData(recurse: boolean = true): GenericVector {
+		const result = new (<any> this.sec).ObjectVector();
+		const owner = this._findOwner();
+		this._collectGraphicsData(result, this.adaptee, owner, !!recurse, true);
+		return result;
+	}
+
+	private _drawGraphicsDataItem(item: any): void {
+		if (!item)
+			return;
+
+		const display = (<SecurityDomain> this.sec).flash.display;
+
+		if (display.GraphicsSolidFill.axIsType(item)) {
+			this.beginFill(item.color, item.alpha);
+			return;
+		}
+
+		if (display.GraphicsGradientFill.axIsType(item)) {
+			this.beginGradientFill(
+				item.type, item.colors, item.alphas, item.ratios,
+				item.matrix, item.spreadMethod, item.interpolationMethod, item.focalPointRatio);
+			return;
+		}
+
+		if (display.GraphicsBitmapFill.axIsType(item)) {
+			this.beginBitmapFill(item.bitmapData, item.matrix, item.repeat, item.smooth);
+			return;
+		}
+
+		if (display.GraphicsEndFill.axIsType(item)) {
+			this.endFill();
+			return;
+		}
+
+		if (display.GraphicsStroke.axIsType(item)) {
+			this._applyStroke(item);
+			return;
+		}
+
+		if (display.GraphicsPath.axIsType(item)) {
+			this.drawPath(item.commands, item.data, item.winding);
+			return;
+		}
+
+		if (display.GraphicsTrianglePath.axIsType(item)) {
+			// AIR readGraphicsData skips triangles; drawTriangles is not implemented.
+			return;
+		}
+
+		// Engine IGraphicsData (has data_type) can be forwarded directly.
+		if (item.data_type && this.adaptee)
+			this.adaptee.drawGraphicsData([item]);
+	}
+
+	private _applyStroke(stroke: GraphicsStroke): void {
+		const fill: any = stroke.fill;
+		let color = 0;
+		let alpha = 1;
+
+		const display = (<SecurityDomain> this.sec).flash.display;
+
+		if (display.GraphicsSolidFill.axIsType(fill)) {
+			color = fill.color;
+			alpha = fill.alpha;
+		}
+
+		this.lineStyle(
+			stroke.thickness, color, alpha,
+			stroke.pixelHinting, stroke.scaleMode,
+			stroke.caps, stroke.joints, stroke.miterLimit);
+
+		if (display.GraphicsGradientFill.axIsType(fill)) {
+			this.lineGradientStyle(
+				fill.type, fill.colors, fill.alphas, fill.ratios,
+				fill.matrix, fill.spreadMethod, fill.interpolationMethod, fill.focalPointRatio);
+			return;
+		}
+
+		if (display.GraphicsBitmapFill.axIsType(fill)) {
+			this.lineBitmapStyle(fill.bitmapData, fill.matrix, fill.repeat, fill.smooth);
+		}
+	}
+
+	private _collectGraphicsData(
+		result: GenericVector,
+		awayGraphics: AwayGraphics | undefined,
+		owner: DisplayObject,
+		recurse: boolean,
+		isRoot: boolean
+	): void {
+		if (!isRoot && (owner.visible === false || owner.adaptee.maskMode))
+			return;
+
+		if (awayGraphics) {
+			// AIR: IGraphicsData is in the local space of the Graphics being read.
+			// Recursed children are transformed into that object's space, not stage space.
+			const matrix = isRoot ? new AwayMatrix() : this._concatenatedMatrix(owner);
+			const items = awayGraphics.readGraphicsData();
+			for (let i = 0; i < items.length; i++) {
+				const as3 = this._toAS3GraphicsData(items[i], matrix);
+				if (as3)
+					result.axSetNumericProperty(result.length, as3);
+			}
+		}
+
+		if (!recurse || !owner || !(<SecurityDomain> this.sec).flash.display.DisplayObjectContainer.axIsType(owner))
+			return;
+
+		const container = <DisplayObjectContainer> owner;
+		const n = container.numChildren;
+		for (let i = 0; i < n; i++) {
+			const child = container.getChildAt(i);
+			if (child.visible === false || child.adaptee.maskMode)
+				continue;
+
+			this._collectGraphicsData(result, (<Sprite> child).graphics?.adaptee, child, true, false);
+		}
+	}
+
+	/**
+	 * Resolve the AS3 display object that owns this wrapper at call time from
+	 * the AwayGraphics owner set (held weakly by AwayGraphics). The owner is
+	 * the one whose AS3 adapter exposes this exact wrapper as its graphics,
+	 * which stays exact when several timeline instances share one AwayGraphics.
+	 */
+	private _findOwner(): DisplayObject {
+		let found: DisplayObject = null;
+
+		this._adaptee.forEachOwner((awayOwner: IContainer) => {
+			if (found)
+				return;
+			const adapter: Sprite = <Sprite> awayOwner.adapter;
+			if (adapter.graphics === this)
+				found = adapter;
+		});
+		return found;
+	}
+
+	private _concatenatedMatrix(obj: DisplayObject): AwayMatrix {
+		const result = new AwayMatrix();
+		const stack: AwayMatrix[] = [];
+		let current: DisplayObject = obj;
+		while (current) {
+			const transform = current.adaptee && (<any> current.adaptee).transform;
+			const local = transform && transform.matrix;
+			if (local)
+				stack.push(local);
+			current = current.parent;
+		}
+		for (let i = stack.length - 1; i >= 0; i--)
+			result.concat(stack[i]);
+		return result;
+	}
+
+	private _toAS3GraphicsData(item: AwayIGraphicsData, concatenated: AwayMatrix): IGraphicsData {
+
+		const display = (<SecurityDomain> this.sec).flash.display;
+		const type = item.data_type;
+
+		if (type == GraphicsFillStyle.data_type)
+			return this._toAS3GraphicsData((<GraphicsFillStyle<any>> item).fillStyle, concatenated);
+
+		if (type == SolidFillStyle.data_type) {
+			const solid = <SolidFillStyle> item;
+			return new display.GraphicsSolidFill(solid.color, solid.alpha);
+		}
+
+		if (type == GradientFillStyle.data_type) {
+			const gradient = <GradientFillStyle> item;
+			const matrix = concatenated.clone()
+			matrix.concat(gradient.matrix);
+			return new display.GraphicsGradientFill(
+				gradient.type,
+				this.sec.createArray(gradient.colors),
+				this.sec.createArray(gradient.alphas),
+				this.sec.createArray(gradient.ratios),
+				new (<SecurityDomain> this.sec).flash.geom.Matrix(matrix),
+				gradient.spreadMethod,
+				gradient.interpolationMethod,
+				gradient.focalPointRatio
+			);
+		}
+
+		if (type == BitmapFillStyle.data_type) {
+			const bitmap = <BitmapFillStyle> item;
+			const matrix = concatenated.clone()
+			matrix.concat(bitmap.matrix);
+			return new display.GraphicsBitmapFill(
+				<BitmapData> bitmap.image.adapter,
+				new (<SecurityDomain> this.sec).flash.geom.Matrix(matrix),
+				bitmap.repeat !== false,
+				!!bitmap.smooth
+			);
+		}
+
+		if (type == AwayGraphicsEndFill.data_type)
+			return new display.GraphicsEndFill();
+
+		if (type == GraphicsStrokeStyle.data_type) {
+			const stroke = <GraphicsStrokeStyle<any>> item;
+			const fill = this._toAS3GraphicsData(this._strokeFill(stroke), concatenated);
+			return new display.GraphicsStroke(
+				stroke.thickness,
+				false,
+				'normal',
+				styleName(CAPS_STYLES, stroke.capstyle),
+				styleName(JOINT_STYLES, stroke.jointstyle),
+				stroke.miterLimit,
+				fill
+			);
+		}
+
+		if (type == AwayGraphicsPath.data_type) {
+			const path = <AwayGraphicsPath> item;
+			const winding = path.winding === 'nonZero' ? 'nonZero' : 'evenOdd';
+			const commands = this._toInt32Vector(path.commands);
+			const data = this._toFloat64Vector(this._transformPairs(path.data, concatenated));
+			// Construct with a valid winding first (ABC validates it). Then poke
+			// commands/data onto both JS fields and $Bg slots — the ABC ctor does not.
+			const as3: any = new display.GraphicsPath(null, null, winding);
+			as3.commands = commands;
+			as3.data = data;
+			as3.winding = winding;
+			as3.$Bgcommands = commands;
+			as3.$Bgdata = data;
+			as3.$Bgwinding = winding;
+			return as3;
+		}
+
+		return null;
+	}
+
+	private _strokeFill(stroke: GraphicsStrokeStyle<any>): AwayIGraphicsData {
+		let fill: any = stroke.fillStyle;
+		if (fill && fill.data_type == GraphicsFillStyle.data_type)
+			fill = fill.fillStyle;
+		return fill;
+	}
+
+	private _transformPairs(data: number[], matrix: AwayMatrix): number[] {
+		if (!data)
+			return [];
+		if (!matrix || data.length < 2)
+			return data;
+
+		const raw = matrix.rawData;
+		const a = raw[0], b = raw[1], c = raw[2], d = raw[3], tx = raw[4], ty = raw[5];
+		if (a === 1 && b === 0 && c === 0 && d === 1 && tx === 0 && ty === 0)
+			return data;
+
+		const out = data.slice();
+		for (let i = 0; i + 1 < out.length; i += 2) {
+			const x = out[i];
+			const y = out[i + 1];
+			out[i] = a * x + c * y + tx;
+			out[i + 1] = b * x + d * y + ty;
+		}
+		return out;
+	}
+
+	private _toInt32Vector(values: number[]): Int32Vector {
+		const list = values || [];
+		const vector = new this.sec.Int32Vector(list.length, false);
+		for (let i = 0; i < list.length; i++)
+			vector.axSetNumericProperty(i, list[i]);
+		return vector;
+	}
+
+	private _toFloat64Vector(values: number[]): Float64Vector {
+		const list = values || [];
+		const vector = new this.sec.Float64Vector(list.length, false);
+		for (let i = 0; i < list.length; i++)
+			vector.axSetNumericProperty(i, +list[i]);
+		return vector;
+	}
+}

package/lib/display/GraphicsBitmapFill.ts

@@ -0,0 +1,39 @@
+import { ASObject } from '@awayfl/avm2';
+import { Matrix } from '../geom/Matrix';
+import { BitmapData } from './BitmapData';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+
+export class GraphicsBitmapFill extends ASObject implements IGraphicsFill, IGraphicsData {
+
+	public static classInitializer: any = function (this: any) {
+		// playerglobal.abcs ships a bytecode ctor that never assigns the native
+		// fields. AS3 `new GraphicsBitmapFill(bd, matrix, …)` then produces an
+		// instance whose $BgbitmapData slot stays null. Bind the TS constructor.
+		const proto = this.tPrototype || this.dPrototype;
+		if (proto)
+			proto.axInitializer = GraphicsBitmapFill;
+	};
+
+	public bitmapData: BitmapData;
+	public matrix: Matrix;
+	public repeat: boolean;
+	public smooth: boolean;
+
+	constructor(bitmapData: BitmapData = null,
+		matrix: Matrix = null, repeat: boolean = true, smooth: boolean = false) {
+		super();
+		this.bitmapData = bitmapData;
+		this.matrix = matrix;
+		this.repeat = !!repeat;
+		this.smooth = !!smooth;
+		const self = <any> this;
+		self.$BgbitmapData = bitmapData;
+		self.$Bgmatrix = matrix;
+		self.$Bgrepeat = this.repeat;
+		self.$Bgsmooth = this.smooth;
+		self._nativeBitmapData = bitmapData;
+		self._nativeMatrix = matrix;
+		self._nativeRepeat = this.repeat;
+		self._nativeSmooth = this.smooth;
+	}
+}

package/lib/display/GraphicsEndFill.ts

@@ -0,0 +1,11 @@
+import { ASObject } from '@awayfl/avm2';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+
+export class GraphicsEndFill extends ASObject implements IGraphicsFill, IGraphicsData {
+
+	public static classInitializer: any = null;
+
+	constructor() {
+		super();
+	}
+}

package/lib/display/GraphicsGradientFill.ts

@@ -0,0 +1,31 @@
+import { ASArray, ASObject, axCoerceString } from '@awayfl/avm2';
+import { Matrix } from '../geom/Matrix';
+import { IGraphicsData, IGraphicsFill } from './IGraphicsData';
+
+export class GraphicsGradientFill extends ASObject implements IGraphicsFill, IGraphicsData {
+
+	public static classInitializer: any = null;
+
+	public colors: ASArray;
+	public alphas: ASArray;
+	public ratios: ASArray;
+	public matrix: Matrix;
+	public focalPointRatio: number;
+	public type: string;
+	public spreadMethod: any;
+	public interpolationMethod: string;
+
+	constructor(type: string = 'linear', colors: ASArray = null, alphas: ASArray = null,
+		ratios: ASArray = null, matrix: any = null, spreadMethod: any = 'pad',
+		interpolationMethod: string = 'rgb', focalPointRatio: number = 0) {
+		super();
+		this.type = axCoerceString(type);
+		this.colors = colors;
+		this.alphas = alphas;
+		this.ratios = ratios;
+		this.matrix = matrix;
+		this.spreadMethod = spreadMethod;
+		this.interpolationMethod = axCoerceString(interpolationMethod);
+		this.focalPointRatio = +focalPointRatio;
+	}
+}