How to properly dispose of bitmap from MovieClipMaterial

Hi!

I've got problems with MovieClipMaterial

When I change the material the bitmap from MovieClipMaterial remains in alt3d engine and is still used.

First i change the material to new one and then I try:
mcMaterial.texture.bitmapData.dispose();

Bu then I get errors every frame: (even when there is another material assigned to the object)

ArgumentError: Error #2015: Invalid BitmapData.
at flash.display::BitmapData/fillRect()
at alternativa.engine3d.materials::MovieClipMaterial/redraw()[G:\works\Alternativa3D\src\alternativa\engine3d\materials\MovieClipMaterial.as:111]

thx
T76

This message was edited 1 time. Last update was at 11/09/2010 21:37:43

There's a bug in MovieClipMaterial. It's unlikely that there will be fix updates for 5.x version, so you can use this code for the material class to make your own.

package alternativa.engine3d.materials {

import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.core.Surface;
	import alternativa.engine3d.events.MouseEvent3D;
	import alternativa.types.Texture;
	
	import flash.display.BitmapData;
	import flash.display.BlendMode;
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.geom.Matrix;
	import flash.geom.Rectangle;
	
	use namespace alternativa3d;

public class MovieClipMaterial extends TextureMaterial {
		
		public var fillColor:uint;

private var _movieClip:MovieClip;
		private var texWidth:uint;
		private var texHeight:uint;
		private var _fillRect:Rectangle;
		private var _clipRect:Rectangle;
		private var _matrix:Matrix;
		private var _refreshRate:int;
		private var _refreshCounter:int;

public function MovieClipMaterial(movieClip:MovieClip, textureWidth:uint, textureHeight:uint, clipRect:Rectangle = null, matrix:Matrix = null, smooth:Boolean = false, precision:Number = 10, fillColor:uint = 0, refreshRate:int = 1) {
			texWidth = textureWidth;
			texHeight = textureHeight;
			_fillRect = new Rectangle(0, 0, texWidth, texHeight);
			if (clipRect != null) {
				_clipRect = clipRect.clone();
			}
			if (matrix != null) {
				_matrix = matrix.clone();
			}
			_texture = new Texture(new BitmapData(texWidth, texHeight));
			this.refreshRate = refreshRate;
			this.movieClip = movieClip;
			this.fillColor = fillColor;
			
			super(_texture, 1, false, smooth, BlendMode.NORMAL, -1, 0, precision);
		}

public function get movieClip():MovieClip {
			return _movieClip;
		}
		
		public function set movieClip(value:MovieClip):void {
			if (value != _movieClip) {
				if (_movieClip != null) {
					// FIX begin
					if (_movieClip.parent != null)
						_movieClip.parent.removeChild(_movieClip);
					// FIX end
					_movieClip.removeEventListener(Event.ENTER_FRAME, redraw);
				}
				_movieClip = value;
				if (_movieClip != null) {
					_movieClip.addEventListener(Event.ENTER_FRAME, redraw);
				} else {
					_texture.bitmapData.fillRect(_fillRect, fillColor);
				}
			}
		}
		
		private function redraw(e:Event):void {
			if (_movieClip != null) {
				_refreshCounter++;
				if (_refreshCounter == _refreshRate) {
					_refreshCounter = 0;
					_texture.bitmapData.fillRect(_fillRect, fillColor);
					_texture.bitmapData.draw(_movieClip, _matrix, null, BlendMode.NORMAL, _clipRect, _smooth);
				}
			}
		}
		
		override alternativa3d function addToSurface(surface:Surface):void {
			super.addToSurface(surface);
			surface.addEventListener(MouseEvent3D.MOUSE_MOVE, onSurfaceMouseMove);
			surface.addEventListener(MouseEvent3D.MOUSE_OVER, onSurfaceMouseOverOut);
			surface.addEventListener(MouseEvent3D.MOUSE_OUT, onSurfaceMouseOverOut);
		}

override alternativa3d function removeFromSurface(surface:Surface):void {
			super.removeFromSurface(surface);
			surface.removeEventListener(MouseEvent3D.MOUSE_MOVE, onSurfaceMouseMove);
			surface.removeEventListener(MouseEvent3D.MOUSE_OVER, onSurfaceMouseOverOut);
			surface.removeEventListener(MouseEvent3D.MOUSE_OUT, onSurfaceMouseOverOut);
		}
		
		private function onSurfaceMouseMove(e:MouseEvent3D):void {
			if (_movieClip != null) {
				_movieClip.x = e.view.mouseX - texWidth*e.u;
				_movieClip.y = e.view.mouseY - texHeight*(1 - e.v);
			}
		}
		
		private function onSurfaceMouseOverOut(e:MouseEvent3D):void {
			if (_movieClip != null) {
				if (e.type == MouseEvent3D.MOUSE_OVER) {
					e.view.addChild(_movieClip);
					_movieClip.alpha = 0;
				} else {
					if (_movieClip.parent == e.view) {
						e.view.removeChild(_movieClip);
					}
				}
			}
		}
		
		override public function set texture(value:Texture):void {
		}
		
		public function get refreshRate():int {
			return _refreshRate;
		}

public function set refreshRate(value:int):void {
			_refreshRate = value > 0 ? value : 1;
		}
		
		public function get clipRect():Rectangle {
			return _clipRect == null ? null : _clipRect.clone();
		}
		
		public function set clipRect(value:Rectangle):void {
			_clipRect = value;
		}
		
		public function get matrix():Matrix {
			return _matrix == null ? null : _matrix.clone();
		}
		
		public function set matrix(value:Matrix):void {
			_matrix = value;
		}
		
		override public function clone():Material {
			return new MovieClipMaterial(_movieClip, texWidth, texHeight, _clipRect, _matrix, _smooth, _precision, fillColor, _refreshRate);
		}

}
}

how about opensourcing the rest of it? could make some noise on teh interwebs