Here is what I do:

1) I declare an empty grid at start:
this.grid = new ShuffleGrid(0, 0, ThumbGiftZone.WIDTH, ThumbGiftZone.HEIGHT, paddingGrid);
addChild(grid)

2) I add (in a loop or not) items to the grid with:

var maxCols:uint = Math.floor(stage.stageWidth / (ThumbGiftZone.WIDTH + padding));
grid.updateIndexArray(1, maxCols);

var thumb:ThumbGiftZone = new ThumbGiftZone();
grid.addItem(thumb);

You can see I added a new function inside ShuffleGrid.as, here it is:

public function updateIndexArray(numToAdd:int, maxCols:int):void
		{
			var tempNumItems:uint = numItems + numToAdd;
			var i:int;
			var j:int;
			var cols:int;
			var dif:int;

			var rows:int = Math.ceil(tempNumItems / maxCols);

			for (i = 0; i < rows; i++)
			{
				if(_index.length < rows)
				{
					_index.push(new Array());
				}

				// Pour chaque row on détermine le nombre de col. Tous sauf la dernière auront le maxCols
				cols = (i < rows-1)?maxCols:tempNumItems - (i * maxCols);

				if(_index[i].length < cols)
				{
					dif = cols - _index[i].length;
					for (j = 0; j  1)?maxCols:cols;
		}

Then I did chane shuffelItems:

private function shuffleItems() : void
		{
			var itemVO : ShuffleGridItemVO = _dictionary[_currentItem];
			var cell : Point = getCell(_currentItem.x, _currentItem.y);

			var col : int = cell.x;
			var row : int = (getItemAtPosition(cell.y, cell.x) != null)?cell.y: itemVO.row;

			if(col == itemVO.col && row == itemVO.row)
			{
				return;
			}

			var hMove : int = col - itemVO.col;
			var vMove : int = (row == itemVO.row)?0:row - itemVO.row;

			var i : int;
			var item : ShuffleGridItemVO;
			var move : Array = [];

			if(hMove = itemVO.col + hMove; i--)
				{
					if(_index[itemVO.row][i])
					{
						item = _index[itemVO.row][i];
						item.col++;

						_index[item.row][item.col] = item;
						move.push(item);
					}
				}
			}
			else
			{
				for (i = itemVO.col + 1;i <= itemVO.col + hMove; i++)
				{
					if(_index[itemVO.row][i])
					{
						item = _index[itemVO.row][i];
						item.col--;

						_index[item.row][item.col] = item;
						move.push(item);
					}
				}
			}

			if(vMove = itemVO.row + vMove; i--)
				{
					if(_index[i][itemVO.col + hMove])
					{
						item = _index[i][itemVO.col + hMove];
						item.row++;

						if(item.col >= _index[item.row].length)
						{
							item.col = _index[item.row].length - 1;
						}

						_index[item.row][item.col] = item;
						move.push(item);
					}
				}
			}
			else
			{
				for (i = itemVO.row + 1;i <= itemVO.row + vMove; i++)
				{

					if(_index[i][itemVO.col + hMove])
					{
						item = _index[i][itemVO.col + hMove];
						item.row--;

						_index[item.row][item.col] = item;
						move.push(item);
					}
				}
			}

			for (i = 0;i  col)
			{
				itemVO.col = col;
			}

			_index[row][itemVO.col] = itemVO;
		}

AND getItemAtPosition

public function getItemAtPosition(row : int, col : int) : ShuffleGridItemVO
		{
			var item:ShuffleGridItemVO;

			if(_index[row] != null && _index[row].length > col)
			{
				item = _index[row][col];
			}else
			{
				item = null;
			}
			return item;
		}

The whole idea I use is that, even though there is a grid of 6 x 2 for example, if there no “thumb” at row 2, col 3 then I don’t allow the move and don’t update the v move during the shuffleItems()

Yes, you’re right it’s desirable to nullify the 3D transformation matrix once you’re done rotating so that Flash player won’t draw the plane as a bitmap.

I need to update this class as there are a few little bugs and improvements, so I’ll be sure to include this feature.

Thanks!

http://www.flashandmath.com/flashcs4/blursol/index.html

WIthout adding in that code, once a plane is rotated and rotated back to 0, it was not pixel precise. Here is my modification that made it work:

public function set front( value:DisplayObject ):void
{
if ( _front && contains( _front ) )
{
removeChild( _front );
}

var photoXFactor:Number=value.width/(value.width+1);
var photoYFactor:Number=value.height/(value.height+1);
_front = addChild( value );
_front.scaleX = photoXFactor
_front.scaleY = photoYFactor
_front.z = 0
alignFaces();
}

This may be a simple one to asnwer…..How can I make the track loop??

The 0 bitwise shift simple floors the number, so it is the same as Math.floor() but faster to compute. You could also cast the number to an integer, which is also fast:

for (var i:int = 0; i < int( d * .6); i++)

var n : int = d * .6;
for (var i:int = 0; i < n; i++)
[...]