Error #3670: Buffer too big.

JohnBlackburne

If you have a model with smooth curved surfaces but also edges you don’t want smoothed, the logical thing is to break it up along those edges. So it becomes a series of patches you interpolate across, joined at the edges. The normals should interpolate across the patches but at edges you have discontinuities. Vertices will line up but with distinct normals for triangles in different patches.

So e.g. a cylinder needs 3 patches. One for the curved surface and one for each circular end.

In some cases it might not be possible to cleanly separate patches along non-smooth edges. It’s hard to think of an example of this so I imagine it’s not very common. Something with a cross section like a water droplet icon for example, smooth except along one edge. In such cases it might be necessary to create a smooth patch then manually bring the points together to form an edge. The edge is then made up of pairs of vertices which are distinct in the mesh and so have distinct normals.

DanielKotzer

this is too complicated, I think the simple answer would be to go through the vertices array, and if you see a duplicated one, which also has duplicated normal's, then you take it out, and replace it's number in the index array, finished. you don't deal with the sharp edges at all. that is the way to optimize the mesh.

I saw on the x3d file code there is something called: "normalIndex"

it is an array that contains the indexing of the normal's, I wonder what is that for? I don't use it on my Stage3d software but what could this be possibly used for?

DanielKotzer

though I also have to check on the texture coordinates and indexing, the mapping could also become distorted if you take out vertices.

JohnBlackburne

That would work, in that it would optimise any vertex/normal pair that is duplicated. My only concern is that the example you described earlier, with only two triangles, it came up with distinct normals.

I don’t know if there is something you can do when creating the mesh, to force it to generate and use one normal per vertex. I have no experience of 3D packages or their file formats, so can’t help you with the "normalIndex" and whether it would help.

DanielKotzer

what about the texture coordinates, here is a x3d code for the same 2 triangles mesh I made, but this time with texture:

<IndexedFaceSet DEF='Plane001_0-GEOMETRY' solid='false' coordIndex='0 1 2 -1 3 4 5 -1 ' normalIndex='0 1 2 -1 3 4 5 -1 ' texCoordIndex='0 1 2 -1 3 4 5 -1 ' >
					<Coordinate point='-555.500122 -550.973633 -555.499512, -555.500122 0.000000 555.500488, 555.500061 0.000000 -555.499512, 555.500000 -550.973633 555.500488, 555.500061 0.000000 -555.499512, -555.500122 0.000000 555.500488'/>
					<Normal vector='-0.524565 0.753184 0.396920, -0.524565 0.753184 0.396920, -0.524565 0.753184 0.396920, 0.231870 0.103994 0.967172, 0.231870 0.103994 0.967172, 0.231870 0.103994 0.967172'/>
					<TextureCoordinate point='0.000000 1.000000, 0.000000 0.000000, 1.000000 1.000000, 1.000000 0.000000, 1.000000 1.000000, 0.000000 0.000000' />
				</IndexedFaceSet>

I have no use for the texCoordIndex, but the TextureCoordinate I am using, can I just take out the texture coordinates of the vertices I took out, or will it have a bad effect on the texturing?

DanielKotzer

the 3 and 5 vertices are the same, and so are the texture coordinates in this mesh, I wonder what will happen if I'll use more complicated texturing... ❓

DanielKotzer

here is the code for a "crazy" uv mapping of the object:

<IndexedFaceSet DEF='Plane001_0-GEOMETRY' solid='false' coordIndex='0 1 2 -1 3 4 5 -1 ' normalIndex='0 1 2 -1 3 4 5 -1 ' texCoordIndex='0 1 2 -1 3 4 5 -1 ' >
					<Coordinate point='-555.500122 -550.973633 -555.499512, -555.500122 0.000000 555.500488, 555.500061 0.000000 -555.499512, 555.500000 -550.973633 555.500488, 555.500061 0.000000 -555.499512, -555.500122 0.000000 555.500488'/>
					<Normal vector='-0.524565 0.753184 0.396920, -0.524565 0.753184 0.396920, -0.524565 0.753184 0.396920, 0.231870 0.103994 0.967172, 0.231870 0.103994 0.967172, 0.231870 0.103994 0.967172'/>
					<TextureCoordinate point='2.969616 0.114956, 0.573423 2.556300, -0.151316 -1.912018, -0.956925 1.240762, 0.589081 -1.912018, 1.919934 2.556300' />
				</IndexedFaceSet>

as you can see the duplicated vertices 3 and 5 have different uv mapping.

JohnBlackburne

If duplicate, as in coincident, vertices have different texture coordinates it strongly suggests to me they are part of separately textured patches. This can happen in 3D modelling even where it does not seem necessary, in the middle of an otherwise smooth surface, because the texture has been cut up or rearranged to fit in GPU memory, or if it is textured with tiles.

If so it should only be a minority, perhaps a small fraction, of vertices which are on texture boundaries. You should still be able to optimise most of them, those in the middle of patches so which have just one texture, one pair of texture coords, one normal associated with them.

DanielKotzer

basically, the solution is the same for the vn coordinates as for the normal's, if the vertices and the normal's of these vertices, and the vn coordinates are the same, only then, I take out one of the vertices. I did a function and it worked.

private function OptimizeMesh(vertices:Array,indexes:Array,normals:Array,uvMap:Array):void
		{
			//find matching vertex
			for (var i:int = 0; i<vertices.length; i++)
			{
				//trace("------------------"+i);
				for (var j:int = i+1; j<vertices.length; j++)
				{
					//if match was found
					if (
						( vertices[i] == vertices[j] ) &&
						( normals[i] == normals[j] ) &&
						( (!bitmapData) || (uvMap[i] == uvMap[j]) )
					   )
					{
						//trace("found one: "+j+ " will be replaced by "+i);
						vertices.splice(j, 1);
						normals.splice(j, 1);
						uvMap.splice(j, 1);

						for (var n:int = 0; n<indexes.length; n++)
						{
							if (indexes[n] == j)
									indexes[n] = i;
							else if (indexes[n] > j)
									indexes[n] -= 1;
						}

					}
				}

			}
		}

this optimization process made a big difference, it turned a mesh of 2304 vertices into 649 vertices, the problem is, if you have a big model of 65535 vertices, it can take a very long time to process it, because it has to go through all of the vertices which are 65535 for 65535 times to compere them with the one you check to see if it is a similar ones. this takes to long if you do it at run time. or maybe there is a way to make the code more efficient?

JohnBlackburne

You do a few things in that code that are generally far from optimal. Untyped data is slower in AS3, and every Array contains untyped data. Creating temporary variables of the correct type and comparing those should be quicker.

Also splice is slow, especially as you are doing it a lot. As the resulting Arrays are much smaller it would probably be better build them instead; instead of splicing when you find a match, push the data into output Arrays when you don’t. This reduces the number of checks you need to do, as you only need to check against these new arrays which are initially empty and always smaller.

If it’s still too slow you could hash the data to make the checks much cheaper. E.g. you could add the x, y and z of the vertex, normal, the x,y of the UV data, to produce a single number. Put those in a Vector then just compare these numbers, as identical vertices will generate identical values. To eliminate false positives (most likely perhaps with normals which might have similar but permuted values) apply a different scale to each number.

Finally, you have a check on bitmapData which happens hundreds of time with the same outcome. Better to do this outside the loop, outside the function even. This gives you two functions but they will both be faster.

DanielKotzer

65535 x 65535 = 4294836225 , even if I will reduce it, and make it quicker I find it hard to believe it will be practical to make the optimization at run time. I can make it so that I break every mesh to no more then 5000 vertices, instead of 65535, and then I have only 25000000 (it's less because each iteration is smaller but just for the simplicity) and I'll have to do it 13 times I get 300 million instead of 4.3 billion iteration but then the optimization is much less efficient, I will not get less then a quarter of the original vertices. this is probably not something that should be done at run - time, I'll have to make an application that optimizes the x3d file.

JohnBlackburne

The ways to optimise it that I suggest should benefit it significantly, so are worth trying, as none would be much work.

Another way, which bypasses doing n x n checks altogether: use a Dictionary. Create a hash of the values to act as a key, storing every set of data in the Dictionary. Then a check whether a vertex already exists is just a check whether dict[hash] exists. No need to loop through the array repeatedly, just walk through it once filling a Dictionary with unique sets of vertex data.

DanielKotzer

What do you mean "Dictionary" can you write a short example?

JohnBlackburne

Dictionary is a standard Actionscript class. It’s how it does associative arrays. I don’t use it myself but Starling uses it extensively if you want some examples of it in use.

DanielKotzer

replaced my arrays with signed vectors:

var vnData:Vector.<String> = Vector.<String>( trim(a1).split(",") );

also used dictionary (basically it is a hash table) and did the things you suggested, now it works faster then the speed of light - thanks 🙂

here is my optimization function now:

private function OptimizeMesh2(vertices:Vector.<String>,indexes:Vector.<Number>,normals:Vector.<String>,uvMap:Vector.<String>):void
		{
			trace("vertex number: "+vertices.length);
			var dict:Dictionary = new Dictionary();
			var _vertices:Vector.<String> = Vector.<String>([]);
			var _normals:Vector.<String> = Vector.<String>([]);
			var _uvMap:Vector.<String> = Vector.<String>([]);
			//var counter:int = 0;

			if (bitmapData)
			{
				//create dictionary
				for (var i:int = 0; i<vertices.length; i++)
				{
					if (!dict[String(vertices[i]+normals[i]+uvMap[i])])
						dict[String(vertices[i]+normals[i]+uvMap[i])] = Vector.<int>([i]);
					else
						dict[String(vertices[i]+normals[i]+uvMap[i])].push(i);
				}

				//rebuild the arrays from the dictionary
				for each (var item:Object in dict)
				{
					_vertices.push(vertices[item[0] ]);
					_normals.push(normals[item[0] ]);
					_uvMap.push(uvMap[item[0] ]);
				}
			}
			else
			{
				//create dictionary
				for (var i:int = 0; i<vertices.length; i++)
				{
					if (!dict[String(vertices[i]+normals[i])])
						dict[String(vertices[i]+normals[i])] = Vector.<int>([i]);
					else
						dict[String(vertices[i]+normals[i])].push(i);
				}

				//rebuild the arrays from the dictionary
				for each (var item:Object in dict)
				{
					_vertices.push(vertices[item[0] ]);
					_normals.push(normals[item[0] ]);
				}
			}

			trace("vertex number: "+_vertices.length);
		}

one thing is missing though - how do I rebuild the indexing array without having to loop through the array. I need to take out all the high numbers and reduce those that come after, I used this for loop in the past:

for (var n:int = 0; n<indexes.length; n++)
						{
							if (indexes[n] == j)
									indexes[n] = i;
							else if (indexes[n] > j)
									indexes[n] -= 1;
						}

but now I would like to use dictionary, but can't think of a way to do that. the point is once I take out a number from the index array because I deleted the vertex, I need to offset all the numbers that are higher and how will I do that efficiently? the replacement is easy, but the offset, can you do an offset without a loop? any ideas would be accepted with gratitude.

JohnBlackburne

To update the indices you need a translation table from the old indices to the new ones. And that you can generate as you build the Dictionary. It looks like you are trying to do that by making Vectors of integers for each Dictionary entry, but it would be simpler to e.g. create a separate Vector. Something like like this

var Lookup:Vector.<int> = new Vector.<int>;
	var length = 0;
	for (var i:int = 0; i<vertices.length; i++)
	{
		if (!dict[String(vertices[i]+normals[i])])
		{
			Lookup.push(length);
			dict[String(vertices[i]+normals[i])] = length++;
		}
		else
		{
			Lookup.push(dict[String(vertices[i]+normals[i])])
		}
	}

The 'length' is the length of the current vector, so the offset of a vertex as it’s added. So when you find that vertex again use its value. The resulting 'Lookup' Vector can be used to convert the indexes to match the new data.

JohnBlackburne

Also I’m not 100% sure this will help, but I don’t think Flash will optimise the String operations for you, in which case doing like this could save a lot of work.

var Lookup:Vector.<int> = new Vector.<int>;
	var length = 0;
	for (var i:int = 0; i<vertices.length; i++)
	{
		var str:String = String(vertices[i]+normals[i]);
		if (!dict[str])
		{
			Lookup.push(length);
			dict[str] = length++;
		}
		else
		{
			Lookup.push(dict[str])
		}
	}

DanielKotzer

here is the final optimizing function working fine:

private function OptimizeMesh2(vertices:Vector.<String>,indexes:Vector.<Number>,normals:Vector.<String>,uvMap:Vector.<String>):void
		{
			trace("vertex number: "+vertices.length);

			var dict:Dictionary = new Dictionary();
			var translationTable:Vector.<Number> = Vector.<Number>([]);
			var reduction:int = 0;

			var	vert:String;

			if (bitmapData)
			{
				var temp_vertices:Vector.<String> = vertices.concat();
				vertices.length = 0;
				var temp_normals:Vector.<String> = normals.concat();
				normals.length = 0;
				var temp_uvMap:Vector.<String> = uvMap.concat();
				uvMap.length = 0;

				for (var i:int = 0; i<temp_vertices.length; i++)
				{
					vert = String(temp_vertices[i]+temp_normals[i]+temp_uvMap[i]);
					if (!dict[vert])
					{
						dict[vert] = i-reduction;

						vertices.push(temp_vertices[i]);
						normals.push(temp_normals[i]);
						uvMap.push(temp_uvMap[i]);

						translationTable.push(dict[vert]);
					}
					else
					{
						translationTable.push(dict[vert]);
						reduction++;
					}
				}
			}
			else
			{
				var temp_vertices:Vector.<String> = vertices.concat();
				vertices.length = 0;
				var temp_normals:Vector.<String> = normals.concat();
				normals.length = 0;

				for (var i:int = 0; i<temp_vertices.length; i++)
				{
					vert = String(temp_vertices[i]+temp_normals[i]);
					if (!dict[vert])
					{
						dict[vert] = i-reduction;

						vertices.push(temp_vertices[i]);
						normals.push(temp_normals[i]);

						translationTable.push(dict[vert]);
					}
					else
					{
						translationTable.push(dict[vert]);
						reduction++;
					}
				}
			}

			//rebuild indexes array
			for (var i:int = 0; i<indexes.length; i++)
				indexes[i] = translationTable[indexes[i]];

			trace("vertex number: "+vertices.length);
			trace("----------------");
		}

DanielKotzer

I used this code to duplicate a vector:

var temp_vertices:Vector.<String> = vertices.concat();

is there a more efficient way?

and used this code to empty a vector, so I will not lose the original reference:

vertices.length = 0;

is there a more efficient way?

Shaun_Max

Is there a way to catch this error ? before its too big?

« Previous Page Next Page »