tools/ExtractPoints.js - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

  /**
  * @fileoverview This implements a Photoshop script that can be used to generate
  * collision information for the AndouKun game engine.  This tool walks over
  * each path in the current document and generates a list of edges and normals
  * in a new document.  It is intended to be used on a file containing
  * graphical representations of the collision tiles used by the engine.  Each
  * path in the file must be closed and may not contain any curved points
  * (the tool assumes that the line between any two points in a given path is
  * straight).  Only one shape may be contained per path layer (each path must go
  * in its own path layer).  This tool can also output a graphical version of its
  * edge calculation for debugging purposes.
  */

 /* If set to true, the computation will be rendered graphically to the output
    file */
 var drawOutput = false;
 /* If true, the computation will be printed in a text layer in the
    output file.*/
 var printOutput = true;

 // Back up the ruler units that this file uses before switching to pixel units.
 var defaultRulerUnits = app.preferences.rulerUnits;
 app.preferences.rulerUnits = Units.PIXELS;

 var tileSizeX = prompt("Tile pixel width:");
 var tileSizeY = prompt("Tile pixel height:");

 var documentWidth = app.activeDocument.width;
 var documentHeight = app.activeDocument.height;

 var tilesPerRow = documentWidth / tileSizeX;
 var tilesPerColumn = documentHeight / tileSizeY;

 var tiles = new Array();
 tiles.length = tilesPerRow * tilesPerColumn;

 // Walk the list of paths and extract edges and normals.  Store these in
 // an array by tile.
 var pathList = app.activeDocument.pathItems;
 for (pathIndex = 0; pathIndex < pathList.length; pathIndex++) {
   var main_path = pathList[pathIndex];
   if (main_path) {
     var itemList = main_path.subPathItems;
     if (!itemList) {
       alert("Path has no sub items!");
     } else {
       for (var x = 0; x < itemList.length; x++) {
         var item = itemList[x];
         var points = item.pathPoints;
         var tile = new Object;
         tile.edges = new Array();

         var totalX = 0;
         var totalY = 0;
         for (var y = 0; y < points.length; y++) {
           var firstPoint = points[y];
           var lastPoint = points[(y + 1) % points.length];

           var edge = new Object;

           edge.startX = firstPoint.anchor[0];
           edge.startY = firstPoint.anchor[1];

           edge.endX = lastPoint.anchor[0];
           edge.endY = lastPoint.anchor[1];

           var normalX = -(edge.endY - edge.startY);
           var normalY = edge.endX - edge.startX;

           var normalLength = Math.sqrt((normalX * normalX) + (normalY * normalY));
           normalX /= normalLength;
           normalY /= normalLength;

           edge.normalX = normalX;
           edge.normalY = normalY;

           if (normalX == 0 && normalY == 0) {
             alert("Zero length normal calculated at path " + pathIndex);
           }

           var normalLength2 = Math.sqrt((normalX * normalX) + (normalY * normalY));
           if (normalLength2 > 1 || normalLength2 < 0.9) {
             alert("Normal of invalid length (" + normalLength2 + ") found at path " + pathIndex);
           }

           totalX += edge.endX;
           totalY += edge.endY;

           var width = edge.endX - edge.startX;
           var height = edge.endY - edge.startY;

           edge.centerX = edge.endX - (width / 2);
           edge.centerY = edge.endY - (height / 2);

           tile.edges.push(edge);
         }

         totalX /= points.length;
         totalY /= points.length;
         tile.centerX = totalX;
         tile.centerY = totalY;

         var column = Math.floor(tile.centerX / tileSizeX);
         var row = Math.floor(tile.centerY / tileSizeY);

         tile.xOffset = column * tileSizeX;
         tile.yOffset = row * tileSizeY;

         tile.centerX -= tile.xOffset;
         tile.centerY -= tile.yOffset;

         var tileIndex = Math.floor(row * tilesPerRow + column);
         tiles[tileIndex] = tile;

       }
     }
   }
 }

 var outputString = "";

 // For each tile print the edges to a string.
 for (var x = 0; x < tiles.length; x++) {
   if (tiles[x]) {
     var tile = tiles[x];
     for (var y = 0; y < tile.edges.length; y++) {
       var edge = tile.edges[y];

       // convert to tile space
       edge.startX -= tile.xOffset;
       edge.startY -= tile.yOffset;
       edge.endX -= tile.xOffset;
       edge.endY -= tile.yOffset;
       edge.centerX -= tile.xOffset;
       edge.centerY -= tile.yOffset;

       // The normals that we calculated previously might be facing the wrong
       // direction.  Detect this case and correct it by checking to see if
       // adding the normal to a point on the edge moves the point closer or
       // further from the center of the shape.
       if (Math.abs(edge.centerX - tile.centerX) >
             Math.abs((edge.centerX + edge.normalX) - tile.centerX)) {
         edge.normalX *= -1;
         edge.normalY *= -1;
       }

       if (Math.abs(edge.centerY - tile.centerY) >
             Math.abs((edge.centerY + edge.normalY) - tile.centerY)) {
         edge.normalX *= -1;
         edge.normalY *= -1;
       }


       // Convert to left-handed GL space (the origin is at the bottom-left).
       edge.normalY *= -1;
       edge.startY = tileSizeY - edge.startY;
       edge.endY = tileSizeY - edge.endY;
       edge.centerY = tileSizeY - edge.centerY;

       outputString += x + ":" + Math.floor(edge.startX) + "," +
           Math.floor(edge.startY) + ":" + Math.floor(edge.endX) + "," +
           Math.floor(edge.endY) + ":" + edge.normalX + "," + edge.normalY +
           "\r";
     }
   }
 }


 if (outputString.length > 0) {

     var newDoc = app.documents.add(600, 700, 72.0, "Edge Output",
         NewDocumentMode.RGB);

     if (drawOutput) {
       // Render the edges and normals to the new document.
       var pathLayer = newDoc.artLayers.add();
       newDoc.activeLayer = pathLayer;

       // draw the edges to make sure everything works
       var black = new SolidColor;
       black.rgb.red = 0;
       black.rgb.blue = 0;
       black.rgb.green = 0;

       var redColor = new SolidColor;
       redColor.rgb.red = 255;
       redColor.rgb.blue = 0;
       redColor.rgb.green = 0;

       var greenColor = new SolidColor;
       greenColor.rgb.red = 0;
       greenColor.rgb.blue = 0;
       greenColor.rgb.green = 255;

       var blueColor = new SolidColor;
       blueColor.rgb.red = 0;
       blueColor.rgb.blue = 255;
       blueColor.rgb.green = 0;

       var lineIndex = 0;
       for (var x = 0; x < tiles.length; x++) {
         if (tiles[x]) {
           var tile = tiles[x];
           var lineArray = new Array();
           var offsetX = Math.floor(x % tilesPerRow) * tileSizeX;
           var offsetY = Math.floor(x / tilesPerRow) * tileSizeY;

           for (var y = 0; y < tile.edges.length; y++) {
             var edge = tile.edges[y];

             lineArray[y] = Array(offsetX + edge.startX, offsetY + edge.startY);
           }

           // I tried to do this by stroking paths, but the documentation
           // provided by Adobe is faulty (their sample code doesn't run).  The
           // same thing can be accomplished with selections instead.
           newDoc.selection.select(lineArray);
           newDoc.selection.stroke(black, 2);

           for (var y = 0; y < tile.edges.length; y++) {
             var edge = tile.edges[y];

              var normalX = Math.round(tile.centerX +
                 (edge.normalX * (tileSizeX / 2)));
              var normalY = Math.round(tile.centerY +
                 (edge.normalY * (tileSizeY / 2)));

              var tileCenterArray = new Array();
              tileCenterArray[0] = new Array(offsetX + tile.centerX - 1,
                 offsetY + tile.centerY - 1);
              tileCenterArray[1] = new Array(offsetX + tile.centerX - 1,
                 offsetY + tile.centerY + 1);
              tileCenterArray[2] = new Array(offsetX + tile.centerX + 1,
                 offsetY + tile.centerY + 1);
              tileCenterArray[3] = new Array(offsetX + tile.centerX + 1,
                 offsetY + tile.centerY - 1);
              tileCenterArray[4] = new Array(offsetX + normalX - 1,
                 offsetY + normalY - 1);
              tileCenterArray[5] = new Array(offsetX + normalX + 1,
                 offsetY + normalY + 1);
              tileCenterArray[6] = new Array(offsetX + tile.centerX,
                 offsetY + tile.centerY);

              newDoc.selection.select(tileCenterArray);
              newDoc.selection.fill(redColor);

              var centerArray = new Array();
              centerArray[0] = new Array(offsetX + edge.centerX - 1,
                 offsetY + edge.centerY - 1);
              centerArray[1] = new Array(offsetX + edge.centerX - 1,
                 offsetY + edge.centerY + 1);
              centerArray[2] = new Array(offsetX + edge.centerX + 1,
                 offsetY + edge.centerY + 1);
              centerArray[3] = new Array(offsetX + edge.centerX + 1,
                 offsetY + edge.centerY - 1);

              newDoc.selection.select(centerArray);
              newDoc.selection.fill(greenColor);

           }

         }
       }
     }

     if (printOutput) {
       var textLayer = newDoc.artLayers.add();
       textLayer.kind = LayerKind.TEXT;
       textLayer.textItem.contents = outputString;
     }
 }

 preferences.rulerUnits = defaultRulerUnits;

 // Convenience function for clamping negative values to zero.  Trying to select
 // areas outside the canvas causes Bad Things.
 function clamp(input) {
   if (input < 0) {
     return 0;
   }
   return input;
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @fileoverview This implements a Photoshop script that can be used to generate
	* collision information for the AndouKun game engine. This tool walks over
	* each path in the current document and generates a list of edges and normals
	* in a new document. It is intended to be used on a file containing
	* graphical representations of the collision tiles used by the engine. Each
	* path in the file must be closed and may not contain any curved points
	* (the tool assumes that the line between any two points in a given path is
	* straight). Only one shape may be contained per path layer (each path must go
	* in its own path layer). This tool can also output a graphical version of its
	* edge calculation for debugging purposes.
	*/

	/* If set to true, the computation will be rendered graphically to the output
	file */
	var drawOutput = false;
	/* If true, the computation will be printed in a text layer in the
	output file.*/
	var printOutput = true;

	// Back up the ruler units that this file uses before switching to pixel units.
	var defaultRulerUnits = app.preferences.rulerUnits;
	app.preferences.rulerUnits = Units.PIXELS;

	var tileSizeX = prompt("Tile pixel width:");
	var tileSizeY = prompt("Tile pixel height:");

	var documentWidth = app.activeDocument.width;
	var documentHeight = app.activeDocument.height;

	var tilesPerRow = documentWidth / tileSizeX;
	var tilesPerColumn = documentHeight / tileSizeY;

	var tiles = new Array();
	tiles.length = tilesPerRow * tilesPerColumn;

	// Walk the list of paths and extract edges and normals. Store these in
	// an array by tile.
	var pathList = app.activeDocument.pathItems;
	for (pathIndex = 0; pathIndex < pathList.length; pathIndex++) {
	var main_path = pathList[pathIndex];
	if (main_path) {
	var itemList = main_path.subPathItems;
	if (!itemList) {
	alert("Path has no sub items!");
	} else {
	for (var x = 0; x < itemList.length; x++) {
	var item = itemList[x];
	var points = item.pathPoints;
	var tile = new Object;
	tile.edges = new Array();

	var totalX = 0;
	var totalY = 0;
	for (var y = 0; y < points.length; y++) {
	var firstPoint = points[y];
	var lastPoint = points[(y + 1) % points.length];

	var edge = new Object;

	edge.startX = firstPoint.anchor[0];
	edge.startY = firstPoint.anchor[1];

	edge.endX = lastPoint.anchor[0];
	edge.endY = lastPoint.anchor[1];

	var normalX = -(edge.endY - edge.startY);
	var normalY = edge.endX - edge.startX;

	var normalLength = Math.sqrt((normalX * normalX) + (normalY * normalY));
	normalX /= normalLength;
	normalY /= normalLength;

	edge.normalX = normalX;
	edge.normalY = normalY;

	if (normalX == 0 && normalY == 0) {
	alert("Zero length normal calculated at path " + pathIndex);
	}

	var normalLength2 = Math.sqrt((normalX * normalX) + (normalY * normalY));
	if (normalLength2 > 1 \|\| normalLength2 < 0.9) {
	alert("Normal of invalid length (" + normalLength2 + ") found at path " + pathIndex);
	}

	totalX += edge.endX;
	totalY += edge.endY;

	var width = edge.endX - edge.startX;
	var height = edge.endY - edge.startY;

	edge.centerX = edge.endX - (width / 2);
	edge.centerY = edge.endY - (height / 2);

	tile.edges.push(edge);
	}

	totalX /= points.length;
	totalY /= points.length;
	tile.centerX = totalX;
	tile.centerY = totalY;

	var column = Math.floor(tile.centerX / tileSizeX);
	var row = Math.floor(tile.centerY / tileSizeY);

	tile.xOffset = column * tileSizeX;
	tile.yOffset = row * tileSizeY;

	tile.centerX -= tile.xOffset;
	tile.centerY -= tile.yOffset;

	var tileIndex = Math.floor(row * tilesPerRow + column);
	tiles[tileIndex] = tile;

	}
	}
	}
	}

	var outputString = "";

	// For each tile print the edges to a string.
	for (var x = 0; x < tiles.length; x++) {
	if (tiles[x]) {
	var tile = tiles[x];
	for (var y = 0; y < tile.edges.length; y++) {
	var edge = tile.edges[y];

	// convert to tile space
	edge.startX -= tile.xOffset;
	edge.startY -= tile.yOffset;
	edge.endX -= tile.xOffset;
	edge.endY -= tile.yOffset;
	edge.centerX -= tile.xOffset;
	edge.centerY -= tile.yOffset;

	// The normals that we calculated previously might be facing the wrong
	// direction. Detect this case and correct it by checking to see if
	// adding the normal to a point on the edge moves the point closer or
	// further from the center of the shape.
	if (Math.abs(edge.centerX - tile.centerX) >
	Math.abs((edge.centerX + edge.normalX) - tile.centerX)) {
	edge.normalX *= -1;
	edge.normalY *= -1;
	}

	if (Math.abs(edge.centerY - tile.centerY) >
	Math.abs((edge.centerY + edge.normalY) - tile.centerY)) {
	edge.normalX *= -1;
	edge.normalY *= -1;
	}


	// Convert to left-handed GL space (the origin is at the bottom-left).
	edge.normalY *= -1;
	edge.startY = tileSizeY - edge.startY;
	edge.endY = tileSizeY - edge.endY;
	edge.centerY = tileSizeY - edge.centerY;

	outputString += x + ":" + Math.floor(edge.startX) + "," +
	Math.floor(edge.startY) + ":" + Math.floor(edge.endX) + "," +
	Math.floor(edge.endY) + ":" + edge.normalX + "," + edge.normalY +
	"\r";
	}
	}
	}


	if (outputString.length > 0) {

	var newDoc = app.documents.add(600, 700, 72.0, "Edge Output",
	NewDocumentMode.RGB);

	if (drawOutput) {
	// Render the edges and normals to the new document.
	var pathLayer = newDoc.artLayers.add();
	newDoc.activeLayer = pathLayer;

	// draw the edges to make sure everything works
	var black = new SolidColor;
	black.rgb.red = 0;
	black.rgb.blue = 0;
	black.rgb.green = 0;

	var redColor = new SolidColor;
	redColor.rgb.red = 255;
	redColor.rgb.blue = 0;
	redColor.rgb.green = 0;

	var greenColor = new SolidColor;
	greenColor.rgb.red = 0;
	greenColor.rgb.blue = 0;
	greenColor.rgb.green = 255;

	var blueColor = new SolidColor;
	blueColor.rgb.red = 0;
	blueColor.rgb.blue = 255;
	blueColor.rgb.green = 0;

	var lineIndex = 0;
	for (var x = 0; x < tiles.length; x++) {
	if (tiles[x]) {
	var tile = tiles[x];
	var lineArray = new Array();
	var offsetX = Math.floor(x % tilesPerRow) * tileSizeX;
	var offsetY = Math.floor(x / tilesPerRow) * tileSizeY;

	for (var y = 0; y < tile.edges.length; y++) {
	var edge = tile.edges[y];

	lineArray[y] = Array(offsetX + edge.startX, offsetY + edge.startY);
	}

	// I tried to do this by stroking paths, but the documentation
	// provided by Adobe is faulty (their sample code doesn't run). The
	// same thing can be accomplished with selections instead.
	newDoc.selection.select(lineArray);
	newDoc.selection.stroke(black, 2);

	for (var y = 0; y < tile.edges.length; y++) {
	var edge = tile.edges[y];

	var normalX = Math.round(tile.centerX +
	(edge.normalX * (tileSizeX / 2)));
	var normalY = Math.round(tile.centerY +
	(edge.normalY * (tileSizeY / 2)));

	var tileCenterArray = new Array();
	tileCenterArray[0] = new Array(offsetX + tile.centerX - 1,
	offsetY + tile.centerY - 1);
	tileCenterArray[1] = new Array(offsetX + tile.centerX - 1,
	offsetY + tile.centerY + 1);
	tileCenterArray[2] = new Array(offsetX + tile.centerX + 1,
	offsetY + tile.centerY + 1);
	tileCenterArray[3] = new Array(offsetX + tile.centerX + 1,
	offsetY + tile.centerY - 1);
	tileCenterArray[4] = new Array(offsetX + normalX - 1,
	offsetY + normalY - 1);
	tileCenterArray[5] = new Array(offsetX + normalX + 1,
	offsetY + normalY + 1);
	tileCenterArray[6] = new Array(offsetX + tile.centerX,
	offsetY + tile.centerY);

	newDoc.selection.select(tileCenterArray);
	newDoc.selection.fill(redColor);

	var centerArray = new Array();
	centerArray[0] = new Array(offsetX + edge.centerX - 1,
	offsetY + edge.centerY - 1);
	centerArray[1] = new Array(offsetX + edge.centerX - 1,
	offsetY + edge.centerY + 1);
	centerArray[2] = new Array(offsetX + edge.centerX + 1,
	offsetY + edge.centerY + 1);
	centerArray[3] = new Array(offsetX + edge.centerX + 1,
	offsetY + edge.centerY - 1);

	newDoc.selection.select(centerArray);
	newDoc.selection.fill(greenColor);

	}

	}
	}
	}

	if (printOutput) {
	var textLayer = newDoc.artLayers.add();
	textLayer.kind = LayerKind.TEXT;
	textLayer.textItem.contents = outputString;
	}
	}

	preferences.rulerUnits = defaultRulerUnits;

	// Convenience function for clamping negative values to zero. Trying to select
	// areas outside the canvas causes Bad Things.
	function clamp(input) {
	if (input < 0) {
	return 0;
	}
	return input;
	}