├── Screenshots
    ├── Fence1.PNG
    ├── FenceFinal.PNG
    ├── FenceVerts.PNG
    ├── FenceErosion.PNG
    ├── FenceDilation.PNG
    ├── FenceBinaryimage.PNG
    ├── FenceSubtraction.PNG
    └── FenceVertReduced.PNG
├── README.md
└── destructibleSprite.cs


/Screenshots/Fence1.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/Fence1.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceFinal.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceFinal.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceVerts.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceVerts.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceErosion.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceErosion.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceDilation.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceDilation.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceBinaryimage.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceBinaryimage.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceSubtraction.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceSubtraction.PNG


--------------------------------------------------------------------------------
/Screenshots/FenceVertReduced.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Avatarchik/unity-sprite-runtime-collider-generator/HEAD/Screenshots/FenceVertReduced.PNG


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ##Generating a polygon collider for a sprite at runtime
 2 | 
 3 | <img src="/Screenshots/Fence1.PNG"/>
 4 | 
 5 | Starting with the image we convert the texture to a binary image.
 6 | 
 7 | <img src="/Screenshots/FenceBinaryimage.PNG" width="150"/>
 8 | 
 9 | We perform some image processing techniques to get the outline of the image.
10 | <div style="text-align: center;">
11 | <img src="/Screenshots/FenceDilation.PNG" width="150" style="display: inline-block"/>
12 | <img src="/Screenshots/FenceErosion.PNG" width="150" style="display: inline-block"/>
13 | <img src="/Screenshots/FenceSubtraction.PNG" width="150" style="display: inline-block"/>
14 | </div>
15 | 
16 | From this we follow the outline assigning each pixel as a vertex. We can allow islands( shown in a different colour) and concave shapes.
17 | 
18 | <img src="/Screenshots/FenceVerts.PNG" width="150"/>
19 | 
20 | Removing the unnecessary vertices we can simplify the collider greatly.
21 | 
22 | <img src="/Screenshots/FenceVertReduced.PNG" width="150"/>
23 | 
24 | This lets us generate a collider for complex sprites.
25 | 
26 | <img src="/Screenshots/FenceFinal.PNG" width="150"/>
27 | 


--------------------------------------------------------------------------------
/destructibleSprite.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | 
  5 | public class destructionPolygon : MonoBehaviour {
  6 | 
  7 | 	public Texture2D tex;
  8 | 
  9 | 	public bool doBI;
 10 | 	public bool doErosion;
 11 | 	public bool doDilation;
 12 | 	public bool doSub;
 13 | 	public bool doVert;
 14 | 	
 15 | 	public float pixelsToUnits = 100f; // Pixels to (unity)Units  100 to 1 
 16 | 	public float pixelOffset = 0.5f;
 17 | 
 18 | 	public bool[,] binaryImage;
 19 | 
 20 | 	PolygonCollider2D poly;
 21 | 
 22 | 	public float xBounds;
 23 | 	public float yBounds;
 24 | 
 25 | 	public int islandCount=0;
 26 | 
 27 | 	// Use this for initialization
 28 | 	void Start () {
 29 | 
 30 | 		poly = gameObject.GetComponent<PolygonCollider2D>();
 31 | 
 32 | 		if(poly == null)
 33 | 			poly = gameObject.AddComponent<PolygonCollider2D>();
 34 | 
 35 | 		if(tex == null)
 36 | 			tex = gameObject.GetComponent<SpriteRenderer>().sprite.texture;
 37 | 
 38 | 	 	xBounds = gameObject.GetComponent<SpriteRenderer>().sprite.bounds.extents.x;
 39 | 		yBounds = gameObject.GetComponent<SpriteRenderer>().sprite.bounds.extents.y;
 40 | 
 41 | 		binaryImageFromTex(out binaryImage, ref tex);
 42 | 
 43 | 		gameObject.GetComponent<SpriteRenderer>().sprite.texture.wrapMode = TextureWrapMode.Clamp;
 44 | 		
 45 | 		//		texFromBinaryImage(out tex, binaryImage);
 46 | //		gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 47 | 	}
 48 | 
 49 | 	void Update() {
 50 | 		if(doBI) {
 51 | 			doBI=false;
 52 | 			texFromBinaryImage(out tex, binaryImage);
 53 | 			gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 54 | 		}
 55 | 		
 56 | 		if(doErosion) {
 57 | 			doErosion=false;
 58 | 
 59 | 			texFromBinaryImage(out tex, erosion(ref binaryImage));
 60 | 			gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 61 | 		}
 62 | 		
 63 | 		if(doDilation) {
 64 | 			doDilation=false;
 65 | 
 66 | 			texFromBinaryImage(out tex, dilation(ref binaryImage));
 67 | 			gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 68 | 		}
 69 | 		
 70 | 		if(doSub) {
 71 | 			doSub=false;
 72 | 
 73 | 			texFromBinaryImage(out tex, subtraction(binaryImage, erosion(ref binaryImage)));
 74 | 			gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 75 | 		}
 76 | 		
 77 | 		if(doVert) {
 78 | 			doVert=false;
 79 | 			bool[,] binaryImageOutline = subtraction(binaryImage, erosion(ref binaryImage));
 80 | 			List<List<Vector2> > paths = getPaths(ref binaryImageOutline);
 81 | 
 82 | 			texFromBinaryImageUsingPaths(out tex, binaryImage, paths);
 83 | 			gameObject.GetComponent<SpriteRenderer>().sprite = Sprite.Create(tex, gameObject.GetComponent<SpriteRenderer>().sprite.rect, new Vector2(0.5f, 0.5f));
 84 | 
 85 | 			poly.pathCount = paths.Count;
 86 | 			islandCount = paths.Count;
 87 | 
 88 | 			for(int i=0; i<paths.Count; i++) {
 89 | 				for(int j=0; j<paths[i].Count; j++) {
 90 | 					
 91 | 					
 92 | 					paths[i][j] = new Vector2((paths[i][j].x + pixelOffset)/pixelsToUnits - xBounds, (paths[i][j].y + pixelOffset)/pixelsToUnits - yBounds);
 93 | 					
 94 | 				}
 95 | 				poly.SetPath( i, paths[i].ToArray() );
 96 | 			}
 97 | 		}
 98 | 	}
 99 | 
100 | 	public void updateCollider() {
101 | 
102 | 		tex = gameObject.GetComponent<SpriteRenderer>().sprite.texture;
103 | 		tex.wrapMode = TextureWrapMode.Clamp;
104 | 
105 | 		binaryImageFromTex(out binaryImage, ref tex);
106 | 
107 | 		bool[,] binaryImageOutline = subtraction(binaryImage, erosion(ref binaryImage));
108 | 		List<List<Vector2> > paths = getPaths(ref binaryImageOutline);
109 | 		// simplify paths
110 | 		// convert paths to world space paths
111 | 		
112 | 		poly.pathCount = paths.Count;
113 | 		islandCount = paths.Count;
114 | 		
115 | 		for(int i=0; i<paths.Count; i++) {
116 | 			for(int j=0; j<paths[i].Count; j++) {
117 | 				paths[i][j] = new Vector2((paths[i][j].x + pixelOffset)/pixelsToUnits - xBounds, (paths[i][j].y + pixelOffset)/pixelsToUnits - yBounds);			
118 | 			}
119 | 			poly.SetPath( i,paths[i].ToArray() );
120 | 		}
121 | 	}
122 | 
123 | 	public void updateCollider(Texture2D t) {
124 | 
125 | //		tex = t;
126 | 
127 | 		binaryImageFromTex(out binaryImage, ref t);
128 | 		
129 | 		bool[,] binaryImageOutline = subtraction(binaryImage, erosion(ref binaryImage));
130 | 		List<List<Vector2> > paths = getPaths(ref binaryImageOutline);
131 | 		// simplify paths
132 | 		// convert paths to world space paths
133 | 
134 | 		poly.pathCount = paths.Count;
135 | 		islandCount = paths.Count;
136 | 		
137 | 		for(int i=0; i<paths.Count; i++) {
138 | 			for(int j=0; j<paths[i].Count; j++) {
139 | 				paths[i][j] = new Vector2((paths[i][j].x + pixelOffset)/pixelsToUnits - xBounds, (paths[i][j].y + pixelOffset)/pixelsToUnits - yBounds);			
140 | 			}
141 | 			poly.SetPath( i, paths[i].ToArray() );
142 | 		}
143 | 	}
144 | 
145 | 	// reduces the vert count about 90%
146 | 	List<Vector2> simplifyPath(ref List<Vector2> path) {
147 | 
148 | 		List<Vector2> shortPath = new List<Vector2>();
149 | 
150 | 		Vector2 prevPoint = path[0];
151 | 		int x=(int)path[0].x, y=(int)path[0].y;
152 | 
153 | 		shortPath.Add(prevPoint);
154 | 
155 | 		for(int i=1; i<path.Count; i++) {
156 | 			// if x||y is the same as the previous x||y then we can skip that point
157 | 			if(x!=(int)path[i].x && y!=(int)path[i].y)
158 | 			{	
159 | 				shortPath.Add(prevPoint);
160 | 				x = (int)prevPoint.x;
161 | 				y = (int)prevPoint.y;
162 | 
163 | 				if(shortPath.Count>3) { // if we have more than 3 points we can start checking if we can remove triangle points
164 | 					Vector2 first = shortPath[shortPath.Count-1];
165 | 					Vector2 last = shortPath[shortPath.Count-3];
166 | 					if(first.x == last.x-1 && first.y == last.y-1 ||
167 | 					   first.x == last.x+1 && first.y == last.y+1 ||
168 | 					   first.x == last.x-1 && first.y == last.y+1 ||
169 | 					   first.x == last.x+1 && first.y == last.y-1) {
170 | 						shortPath.RemoveAt(shortPath.Count-2);
171 | 					}
172 | 				}
173 | 				if(shortPath.Count>3) {
174 | 					Vector2 first = shortPath[shortPath.Count-1];
175 | 					Vector2 middle = shortPath[shortPath.Count-2];
176 | 					Vector2 last = shortPath[shortPath.Count-3];
177 | 
178 | 					if((first.x==middle.x+1&&middle.x+1==last.x+2 && first.y==middle.y+1&&middle.y+1==last.y+2) ||
179 | 					   (first.x==middle.x+1&&middle.x+1==last.x+2 && first.y==middle.y-1&&middle.y-1==last.y-2) ||
180 | 					   (first.x==middle.x-1&&middle.x-1==last.x-2 && first.y==middle.y+1&&middle.y+1==last.y+2) ||
181 | 					   (first.x==middle.x-1&&middle.x-1==last.x-2 && first.y==middle.y-1&&middle.y-1==last.y-2)) {
182 | 						shortPath.RemoveAt(shortPath.Count-2);
183 | 					}
184 | 				}
185 | 			}
186 | 			prevPoint = path[i];
187 | 		}
188 | 
189 | //		for(int i=1; i<shortPath.Count; i++) {
190 | //			// if x||y is the same as the previous x||y then we can skip that point
191 | //			if(x!=(int)path[i].x && y!=(int)path[i].y)
192 | //			{	
193 | //				shortPath.Add(prevPoint);
194 | //				x = (int)prevPoint.x;
195 | //				y = (int)prevPoint.y;
196 | //			}
197 | //			prevPoint = path[i];
198 | //		}
199 | 
200 | 		return shortPath;
201 | 	}
202 | 
203 | 	List<List<Vector2> > getPaths(ref bool[,] b) {
204 | 		int w = b.GetLength(0); // width
205 | 		int h = b.GetLength(1); // height
206 | 
207 | 		Vector2 startPoint = Vector2.zero;
208 | 		List<List<Vector2> > paths = new List<List<Vector2> >();
209 | 
210 | 		bool[,] temp = b;//(bool[,]) b.Clone();
211 | 
212 | 		while( findStartPoint(ref temp, ref startPoint) ) {
213 | 			List<Vector2> points = new List<Vector2>();
214 | 
215 | 			// Get vertices from outline
216 | 			List<Vector2> path = getPath2(ref temp, ref points, startPoint);
217 | 
218 | 			// remove points from temp
219 | 			foreach(Vector2 point in path) {
220 | 				temp[(int)point.x,(int)point.y] = false;
221 | 			}
222 | 			paths.Add ( simplifyPath( ref path ) );
223 | //			paths.Add (  path ); //REMOVE
224 | 
225 | 		}
226 | 
227 | 		return paths;
228 | 	}
229 | 	
230 | 	// returns true if found a start point
231 | 	bool findStartPoint(ref bool[,] b, ref Vector2 startPoint) {
232 | 		int w = b.GetLength(0); // width
233 | 		int h = b.GetLength(1); // height
234 | 
235 | 		for(int x= 0; x<w; x++){
236 | 			for(int y= 0; y<h; y++){
237 | 				if(b[x,y]) {
238 | 					startPoint = new Vector2(x,y);
239 | 					Debug.Log("StartPoint: "+ startPoint);
240 | 					return true;
241 | 				}
242 | 			}
243 | 		}
244 | 		return false; // Cannot find any start points.
245 | 	}
246 | 
247 | 	List<Vector2> getPath2(ref bool[,] b, ref List<Vector2> prevPoints, Vector2 startPoint) {
248 | 
249 | 		int[,] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
250 | 		
251 | 		int w = b.GetLength(0); // width
252 | 		int h = b.GetLength(1); // height
253 | 
254 | 		Vector2 currPoint= Vector2.zero, newPoint = Vector2.zero;
255 | 		bool isOpen = true; // Is the path closed?
256 | 
257 | 		for(int z=0; z<dirs.GetLength(0); z++) {
258 | 			int i = (int)startPoint.x + dirs[z,0];
259 | 			int j = (int)startPoint.y + dirs[z,1];
260 | 			if(i<w && i>=0 && j<h && j>=0) {
261 | 				if(b[i,j]) {
262 | 					currPoint = new Vector2(i,j);
263 | 				}
264 | 			}
265 | 		}
266 | 
267 | 		prevPoints.Add(startPoint);
268 | 
269 | 		int count = 0;
270 | 
271 | 		while(isOpen && count<500) {
272 | 			count++;
273 | 
274 | 			Debug.Log(currPoint);
275 | 
276 | 			prevPoints.Add(currPoint);
277 | 			
278 | 			// Check each direction around the start point and repeat for each new point
279 | 			for(int z=0; z<dirs.GetLength(0); z++) {
280 | 				int i = (int)currPoint.x + dirs[z,0];
281 | 				int j = (int)currPoint.y + dirs[z,1];
282 | 				if(i<w && i>=0 && j<h && j>=0) {
283 | 					if(b[i,j]) {
284 | 						if(!prevPoints.Contains(new Vector2(i,j))) {
285 | 							newPoint = new Vector2(i,j);
286 | 							break;
287 | 						} else {
288 | 							if(new Vector2(i,j)==startPoint) {
289 | 								isOpen = false;
290 | 								break;
291 | 							}
292 | 						}
293 | 					}
294 | 				}
295 | 			}
296 | 
297 | 			if(!isOpen) continue;
298 | 
299 | 			// Deadend
300 | 			if(newPoint==currPoint) {
301 | 				for(int p=prevPoints.Count-1; p>=0; p--) {
302 | 					for(int z=0; z<dirs.GetLength(0); z++) {
303 | 						int i = (int)prevPoints[p].x + dirs[z,0];
304 | 						int j = (int)prevPoints[p].y + dirs[z,1];
305 | 						if(i<w && i>=0 && j<h && j>=0) {
306 | 							if(b[i,j]) {
307 | 								if(!prevPoints.Contains(new Vector2(i,j))) {
308 | 									newPoint = new Vector2(i,j);
309 | 									break;
310 | 								}
311 | 							}
312 | 						}
313 | 					}
314 | 					if(newPoint!=currPoint) break;
315 | 				}
316 | 				Debug.Log("NEVER GETS PRINTED");
317 | 			}
318 | 			currPoint = newPoint;
319 | 		}
320 | 		Debug.Log("count<500?: "+count);
321 | 		return prevPoints;
322 | 	}
323 | 
324 | 	// recursive function - its gonna explode
325 | 	// Single island vert mapping
326 | 	List<Vector2> getPath(ref bool[,] b, ref List<Vector2> prevPoints, Vector2 currPoint) {
327 | 		int[,] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
328 | 
329 | 		int w = b.GetLength(0); // width
330 | 		int h = b.GetLength(1); // height
331 | 
332 | 		// get direction
333 | 		if(prevPoints.Count == 0) {
334 | 			prevPoints.Add(currPoint); // startpoint
335 | 
336 | 			for(int z=0; z<dirs.GetLength(0); z++) {
337 | 				int i = (int)currPoint.x + dirs[z,0];
338 | 				int j = (int)currPoint.y + dirs[z,1];
339 | 				if(i<w && i>=0 && j<h && j>=0) {
340 | 					if(b[i,j]) {
341 | 						return getPath (ref b, ref prevPoints, new Vector2(i,j));
342 | 					}
343 | 				}
344 | 			}
345 | 			return prevPoints;
346 | 		}
347 | 
348 | 		for(int z=0; z<dirs.GetLength(0); z++) {
349 | 			int i = (int)currPoint.x + dirs[z,0];
350 | 			int j = (int)currPoint.y + dirs[z,1];
351 | 			if(i<w && i>=0 && j<h && j>=0) {
352 | 				if(b[i,j]) { // if there is a point
353 | 					Vector2 point = new Vector2(i,j);
354 | 					if( prevPoints.Contains(point) ) {
355 | 						if(prevPoints[0] == point && prevPoints.Count>2) {
356 | 							prevPoints.Add (currPoint);
357 | 							return prevPoints;
358 | 						}
359 | 					} else {
360 | 						prevPoints.Add (currPoint);
361 | 						return getPath (ref b, ref prevPoints, point);
362 | 					}
363 | 
364 | //					if(!(i== prevPoints[prevPoints.Count-1].x && j== prevPoints[prevPoints.Count-1].y)) { // check its not the point we just added
365 | //						if(i==prevPoints[0].x && j==prevPoints[0].y && prevPoints[0]!=prevPoints[prevPoints.Count-1]) { // Is it the start point?
366 | //							prevPoints.Add (currPoint);
367 | //							return prevPoints;
368 | //						} else { // Add it and start looking for the next point
369 | //							prevPoints.Add (currPoint);
370 | //							return getPath (ref b, ref prevPoints, new Vector2(i,j));
371 | //						}
372 | //					}
373 | 				}
374 | 			}
375 | 		}
376 | 
377 | 		// Deadend? backtrack to find another path to take
378 | 		for(int p=prevPoints.Count-1; p>=0; p--) {
379 | 			for(int z=0; z<dirs.GetLength(0); z++) {
380 | 				int i = (int)prevPoints[p].x + dirs[z,0];
381 | 				int j = (int)prevPoints[p].y + dirs[z,1];
382 | 				if(i<w && i>=0 && j<h && j>=0) {
383 | 					if(b[i,j]) {
384 | 						if(!prevPoints.Contains(new Vector2(i,j))) {
385 | 							return getPath (ref b, ref prevPoints, new Vector2(i,j));
386 | 						}
387 | 					}
388 | 				}
389 | 			}
390 | 		}
391 | 
392 | 		foreach(Vector2 point in prevPoints) {
393 | 			for(int z=0; z<dirs.GetLength(0); z++) {
394 | 				int i = (int)point.x + dirs[z,0];
395 | 				int j = (int)point.y + dirs[z,1];
396 | 				if(i<w && i>=0 && j<h && j>=0) {
397 | 					if(b[i,j]) {
398 | 						if(!prevPoints.Contains(new Vector2(i,j))) {
399 | 							return getPath (ref b, ref prevPoints, new Vector2(i,j));
400 | 						}
401 | 					}
402 | 				}
403 | 			}
404 | 		}
405 | 
406 | 		return prevPoints; // stupid c# all paths must return crap
407 | 	}
408 | 
409 | 	bool[,] subtraction(bool[,] b1, bool[,] b2) {
410 | 
411 | 		int w = b1.GetLength(0); // width
412 | 		int h = b1.GetLength(1); // height
413 | 
414 | 		bool[,] temp = new bool[w,h];
415 | 
416 | 		for(int x=0; x<w; x++){
417 | 			for(int y=0; y<h; y++){
418 | 				temp[x,y] = (b1[x,y]!=b2[x,y]);
419 | 			}
420 | 		}
421 | 		return temp;
422 | 	}
423 | 
424 | 	// if there is any pixel in a 3x3 grid make the centre one black
425 | 	bool[,] erosion( ref bool[,] b) {
426 | 	
427 | 		int[,] dirs = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
428 | 
429 | 		int w = b.GetLength(0); // width
430 | 		int h = b.GetLength(1);	// height
431 | 
432 | 		bool[,] temp = new bool[w,h];
433 | 		
434 | 		for(int x=0; x<w; x++){
435 | 			for(int y=0; y<h; y++){
436 | 				temp[x,y] = true;
437 | 				for(int z=0; z<dirs.GetLength(0); z++) {
438 | 					int i = x+dirs[z,0];
439 | 					int j = y+dirs[z,1];
440 | 					if(i<w && i>=0 && j<h && j>=0) {
441 | 						if(!b[i,j]) temp[x,y] = false;
442 | 					}
443 | 					else temp[x,y] = false;
444 | 				}
445 | 			}
446 | 		}
447 | 
448 | 		return temp;
449 | 	}
450 | 
451 | 	bool[,] dilation( ref bool[,] b) {
452 | 
453 | 		bool[,] temp = b; //(bool[,]) b.Clone();
454 | 		int[,] dirs = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
455 | 		
456 | 		int w = b.GetLength(0); // width
457 | 		int h = b.GetLength(1);	// height
458 | 
459 | 		for(int x=0; x<w; x++){
460 | 			for(int y=0; y<h; y++){
461 | 				if(b[x,y]) {
462 | 					for(int z=0; z<dirs.GetLength(0); z++) {
463 | 						int i = x+dirs[z,0];
464 | 						int j = y+dirs[z,1];
465 | 						if(i<w && i>=0 && j<h && j>=0)
466 | 							temp[i,j] = true;
467 | //						else temp[i,j] = false; // Should already be false when initialsslslslsed
468 | 					}
469 | 				}
470 | 			}
471 | 		}
472 | 		return temp;
473 | 	}
474 | 
475 | 	void binaryImageFromTex(out bool[,] b, ref Texture2D t) {
476 | 
477 | 		b = new bool[t.width,t.height];
478 | 
479 | 		for(int x=0; x<t.width; x++){
480 | 			for(int y=0; y<t.height; y++){
481 | 				b[x,y] = (t.GetPixel(x,y).a > 0); // If alpha >0 true then 1 else 0
482 | 			}
483 | 		}
484 | 	}
485 | 
486 | 	// test functions below
487 | 	public void texFromBinaryImage(out Texture2D t, bool[,] b) {
488 | 
489 | 		t = new Texture2D(b.GetLength(0),b.GetLength(1));
490 | 		t.wrapMode = TextureWrapMode.Clamp;
491 | 		
492 | 		for(int x=0; x<t.width; x++){
493 | 			for(int y=0; y<t.height; y++){
494 | 				t.SetPixel(x,y, (b[x,y] ? Color.white : Color.black) ); // if true then white else black
495 | 			}
496 | 		}
497 | 		t.Apply();
498 | 	}
499 | 
500 | 	void texFromBinaryImageUsingPaths(out Texture2D t, bool[,] b, List<List<Vector2> > paths) {
501 | 
502 | 		List<Color> colorList = new List<Color>() {
503 | 			Color.red,
504 | 			Color.green,
505 | 			Color.blue,
506 | 			Color.magenta,
507 | 			Color.yellow
508 | 		};
509 | 
510 | 		t = new Texture2D(b.GetLength(0),b.GetLength(1));
511 | 		t.wrapMode = TextureWrapMode.Clamp;
512 | 
513 | 		for(int i=0; i<paths.Count&&i<colorList.Count; i++) {
514 | 			for(int j=0; j<paths[i].Count; j++) {
515 | 				t.SetPixel((int)paths[i][j].x, (int)paths[i][j].y, colorList[i]);
516 | 			}
517 | 		}
518 | 		t.Apply();
519 | 
520 | 	}
521 | 	
522 | }
523 | 


--------------------------------------------------------------------------------