class WebGLGeometry {

 int id;

 int _vertices;

 List faces3, faces4;
 int materialIndex, numMorphTargets, numMorphNormals;

 var geometryGroups, geometryGroupsList;

 bool __webglInit;

 bool __inittedArrays;
 Float32List __vertexArray,
              __normalArray,
              __tangentArray,
              __colorArray,
              __lineDistanceArray,
              __uvArray,
              __uv2Array,
              __skinVertexAArray,
              __skinVertexBArray,
              __skinIndexArray,
              __skinWeightArray;
 Uint16List __faceArray, __lineArray;
 List<Float32List> __morphTargetsArrays, __morphNormalsArrays;
 int __webglFaceCount, __webglLineCount, __webglParticleCount, __webglVertexCount;

 List __sortArray;

 var __webglCustomAttributesList;

 gl.Buffer __webglVertexBuffer,
             __webglNormalBuffer,
             __webglTangentBuffer,
             __webglColorBuffer,
             __webglLineDistanceBuffer,
             __webglUVBuffer,
             __webglUV2Buffer,

             __webglSkinVertexABuffer,
             __webglSkinVertexBBuffer,
             __webglSkinIndicesBuffer,
             __webglSkinWeightsBuffer,

             __webglFaceBuffer,
             __webglLineBuffer;

 List <gl.Buffer> __webglMorphTargetsBuffers, __webglMorphNormalsBuffers;

 Geometry _geometry;

 WebGLGeometry({ this.faces3,
                 this.faces4,
                 this.materialIndex: 0,
                 int vertices: null,
                 this.numMorphTargets: 0,
                 this.numMorphNormals: 0}) : _vertices = vertices;

 WebGLGeometry._internal(Geometry geometry)
 :   _geometry = geometry,
     _vertices = null, // Delegate vertices to geometry
     id = geometry.id,
     materialIndex = 0,
     numMorphTargets = 0,
     numMorphNormals = 0;

 factory WebGLGeometry.from(Geometry geometry) {
   if (geometry["__webglBuffer"] == null) {
     var __webglBuffer = new WebGLGeometry._internal(geometry);
     geometry["__webglBuffer"] = __webglBuffer;
   }

   return geometry["__webglBuffer"];
 }

 // This is weird since vertices can be a List from geometry or a number
 set vertices(int n) => _vertices = n;
 get vertices {
   if (_vertices == null && _geometry != null) {
     return _geometry.vertices;
   }
   return _vertices;
 }

 get offsets => (_geometry as BufferGeometry).offsets;
 get attributes => (_geometry as BufferGeometry).attributes;

 get lineDistances => _geometry.lineDistances;
 getBoolData(key) => _geometry.__data.containsKey(key) ? _geometry[key] : false;

 get verticesNeedUpdate => getBoolData("verticesNeedUpdate");
 set verticesNeedUpdate(bool flag) { _geometry["verticesNeedUpdate"] = flag; }

 get morphTargetsNeedUpdate => getBoolData("morphTargetsNeedUpdate");
 set morphTargetsNeedUpdate(bool flag) { _geometry["morphTargetsNeedUpdate"] = flag; }

 get elementsNeedUpdate => getBoolData("elementsNeedUpdate");
 set elementsNeedUpdate(bool flag) { _geometry["elementsNeedUpdate"] = flag; }

 get uvsNeedUpdate => getBoolData("uvsNeedUpdate");
 set uvsNeedUpdate(bool flag) { _geometry["uvsNeedUpdate"] = flag; }

 get normalsNeedUpdate => getBoolData("normalsNeedUpdate");
 set normalsNeedUpdate(bool flag) { _geometry["normalsNeedUpdate"] = flag; }

 get tangentsNeedUpdate => getBoolData("tangentsNeedUpdate");
 set tangentsNeedUpdate(bool flag) { _geometry["tangentsNeedUpdate"] = flag; }

 get colorsNeedUpdate => getBoolData("colorsNeedUpdate");
 set colorsNeedUpdate(bool flag) { _geometry["colorsNeedUpdate"] = flag; }

 get lineDistancesNeedUpdate => getBoolData("lineDistancesNeedUpdate");
 set lineDistancesNeedUpdate(bool flag) { _geometry["lineDistancesNeedUpdate"] = flag; }

 get buffersNeedUpdate => getBoolData("buffersNeedUpdate");
 set buffersNeedUpdate(bool flag) { _geometry["buffersNeedUpdate"] = flag; }

 get morphTargets => _geometry.morphTargets;
 get morphNormals => _geometry.morphNormals;

 get faces => _geometry.faces;

 get isDynamic => _geometry.isDynamic;

 get faceVertexUvs => _geometry.faceVertexUvs;
 get colors => _geometry.colors;
 get normals => _geometry.normals;
 get skinIndices => _geometry.skinIndices;
 get skinWeights => _geometry.skinWeights;
 get skinVerticesA => _geometry["skinVerticesA"];
 get skinVerticesB => _geometry["skinVerticesB"];

 get hasTangents => _geometry.hasTangents;

 get isBufferGeometry => _geometry is BufferGeometry;
}