text: #ifndef LOAD_MESH_FROM_STL_H
  #define LOAD_MESH_FROM_STL_H
  
  #include "GLInstanceGraphicsShape.h"
  #include <stdio.h>  //fopen
  #include <Bullet3Common/b3AlignedObjectArray.h>
  #include <CommonFileIOInterface.h>
  #include <string.h>  //memcpy
  struct MySTLTriangle
  {
  	float normal[3];
  	float vertex0[3];
  	float vertex1[3];
  	float vertex2[3];
  };
  
  static GLInstanceGraphicsShape* LoadMeshFromSTL(const char* relativeFileName, struct CommonFileIOInterface* fileIO)
  {
  	GLInstanceGraphicsShape* shape = 0;
  
  	int fileHandle = fileIO->fileOpen(relativeFileName, "rb");
  	if (fileHandle >= 0)
  	{
  		int size = 0;
  		size = fileIO->getFileSize(fileHandle);
  		{
  			if (size >= 0)
  			{
  				//b3Warning("Open STL file of %d bytes\n",size);
  				char* memoryBuffer = new char[size + 1];
  				int actualBytesRead = fileIO->fileRead(fileHandle, memoryBuffer, size);
  				if (actualBytesRead != size)
  				{
  					b3Warning("Error reading from file %s", relativeFileName);
  				}
  				else
  				{
  					int numTriangles = *(int*)&memoryBuffer[80];
  
  					if (numTriangles)
  					{
  						{
  							//perform a sanity check instead of crashing on invalid triangles/STL files
  							int expectedBinaryFileSize = numTriangles * 50 + 84;
  							if (expectedBinaryFileSize != size)
  							{
  								delete[] memoryBuffer;
  								fileIO->fileClose(fileHandle);
  								return 0;
  							}
  						}
  						shape = new GLInstanceGraphicsShape;
  						//						b3AlignedObjectArray<GLInstanceVertex>*	m_vertices;
  						//						int				m_numvertices;
  						//						b3AlignedObjectArray<int>* 		m_indices;
  						//						int				m_numIndices;
  						//						float			m_scaling[4];
  						shape->m_scaling[0] = 1;
  						shape->m_scaling[1] = 1;
  						shape->m_scaling[2] = 1;
  						shape->m_scaling[3] = 1;
  						int index = 0;
  						shape->m_indices = new b3AlignedObjectArray<int>();
  						shape->m_vertices = new b3AlignedObjectArray<GLInstanceVertex>();
  						for (int i = 0; i < numTriangles; i++)
  						{
  							char* curPtr = &memoryBuffer[84 + i * 50];
  							MySTLTriangle tmp;
  							memcpy(&tmp, curPtr, sizeof(MySTLTriangle));
  
  							GLInstanceVertex v0, v1, v2;
  							v0.uv[0] = v1.uv[0] = v2.uv[0] = 0.5;
  							v0.uv[1] = v1.uv[1] = v2.uv[1] = 0.5;
  							for (int v = 0; v < 3; v++)
  							{
  								v0.xyzw[v] = tmp.vertex0[v];
  								v1.xyzw[v] = tmp.vertex1[v];
  								v2.xyzw[v] = tmp.vertex2[v];
  								v0.normal[v] = v1.normal[v] = v2.normal[v] = tmp.normal[v];
  							}
  							v0.xyzw[3] = v1.xyzw[3] = v2.xyzw[3] = 0.f;
  
  							shape->m_vertices->push_back(v0);
  							shape->m_vertices->push_back(v1);
  							shape->m_vertices->push_back(v2);
  
  							shape->m_indices->push_back(index++);
  							shape->m_indices->push_back(index++);
  							shape->m_indices->push_back(index++);
  						}
  					}
  				}
  
  				delete[] memoryBuffer;
  			}
  		}
  		fileIO->fileClose(fileHandle);
  	}
  	if (shape)
  	{
  		shape->m_numIndices = shape->m_indices->size();
  		shape->m_numvertices = shape->m_vertices->size();
  	}
  	return shape;
  }
  
  #endif  //LOAD_MESH_FROM_STL_H
  