Schema updates

README.md

@@ -1,6 +1,11 @@
-## glTF - the runtime asset format for WebGL, OpenGL ES, and OpenGL
+<p align="center">
+<img src=“specification/figures/glTF_300.jpg” />
+</p>
+
+glTF is the runtime asset format for WebGL, OpenGL ES, and OpenGL.
+
+_glTF is a draft specification, it may change before ratification._
 
-_glTF is a draft Specification - may change before Ratification -_  
 Everyone is welcomed to contribute to the code and provide feedback about the specification. 
 
 #### Common setup 
@@ -10,9 +15,9 @@ git clone --recurse-submodules https://github.com/KhronosGroup/glTF.git
 
 ## Specification  
 
-_[glTF Specification](https://github.com/KhronosGroup/glTF/blob/master/specification/README.md) is a work-in-progress from the COLLADA Working Group; it is not an official Khronos-ratified specification yet.  It is incomplete and subject to change.  We've made it available early in the spirit of transparency to receive early community feedback.  Please create [issues](https://github.com/KhronosGroup/glTF/issues) with your feedback._
+[glTF Specification 0.6](https://github.com/KhronosGroup/glTF/blob/schema/specification/README.md)
 
-_In particular, the definition of materials are in flux, and work on animations and texture and geometry compression are still in the early stages.  We are also initially focusing on WebGL.  OpenGL ES and OpenGL need additional considerations._
+This is a work-in-progress from the COLLADA Working Group; it is not an official Khronos-ratified specification yet.  We've made it available early in the spirit of transparency to receive early community feedback.  Please create [issues](https://github.com/KhronosGroup/glTF/issues) with your feedback.
 
 ## Converter
 

converter/COLLADA2GLTF/COLLADA2GLTFWriter.cpp

@@ -154,7 +154,7 @@ namespace GLTF
 
         size_t count = primitive->getVertexAttributesCount();
         for (size_t j = 0 ; j < count ; j++) {
-            Semantic semantic = primitive->getSemanticAtIndex(j);
+            Semantic semantic = primitive->getSemanticAtIndex((unsigned int)j);
             std::string semanticString = GLTFUtils::getStringForSemantic(semantic);
 
             shared_ptr<JSONObject> semanticInfo;
@@ -165,7 +165,7 @@ namespace GLTF
 
             unsigned int indexOfSet = 0;
             if (semantic == GLTF::TEXCOORD) {
-                indexOfSet = primitive->getIndexOfSetAtIndex(j);
+				indexOfSet = primitive->getIndexOfSetAtIndex((unsigned int)j);
             }
 
             sets->appendValue(shared_ptr<JSONNumber> (new JSONNumber(indexOfSet)));
@@ -311,7 +311,7 @@ namespace GLTF
                         }
 
                         //generate shaders if needed
-                        shared_ptr <JSONObject> attributeSemantics = serializeAttributeSemanticsForPrimitiveAtIndex(mesh.get(),j);
+						shared_ptr <JSONObject> attributeSemantics = serializeAttributeSemanticsForPrimitiveAtIndex(mesh.get(), (unsigned int)j);
 
                         shared_ptr<JSONObject> techniqueGenerator(new JSONObject());
 
@@ -328,7 +328,7 @@ namespace GLTF
                         //https://github.com/KhronosGroup/glTF/issues/194
                         //We'll deal with two cases cases of default materials
                         //With or without NORMALS
-                        shared_ptr <JSONObject> attributeSemantics = serializeAttributeSemanticsForPrimitiveAtIndex(mesh.get(),j);
+						shared_ptr <JSONObject> attributeSemantics = serializeAttributeSemanticsForPrimitiveAtIndex(mesh.get(), (unsigned int)j);
 
                         static shared_ptr<GLTFEffect> defaultEffectNoNormal = createDefaultEffect(this->_asset.get(), attributeSemantics, false);
                         static shared_ptr<GLTFEffect> defaultEffectWithNormal = createDefaultEffect(this->_asset.get(), attributeSemantics, true);
@@ -492,7 +492,7 @@ namespace GLTF
 
         const InstanceControllerPointerArray& instanceControllers = node->getInstanceControllers();
         shared_ptr <GLTF::JSONArray> meshesArray(new GLTF::JSONArray());
-        unsigned int count = instanceControllers.getCount();
+		unsigned int count = (unsigned int)instanceControllers.getCount();
         if (count > 0) {
             shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded("skins");
             for (unsigned int i = 0 ; i < count; i++) {
@@ -838,7 +838,7 @@ namespace GLTF
 
         if (this->_asset->_samplerHashtoSamplerIndex.count(samplerHash) == 0) {
             index = this->_asset->_samplerHashtoSamplerIndex.size();
-            this->_asset->_samplerHashtoSamplerIndex[samplerHash] = index;            
+			this->_asset->_samplerHashtoSamplerIndex[samplerHash] = (unsigned int)index;
             addSampler = true;
         } else {
             index = this->_asset->_samplerHashtoSamplerIndex[samplerHash];
@@ -1331,12 +1331,12 @@ namespace GLTF
 
         shared_ptr<JSONObject> inverseBindMatrices(new JSONObject());
         inverseBindMatrices->setUnsignedInt32(kType, profile->getGLenumForString("FLOAT_MAT4"));
-        inverseBindMatrices->setUnsignedInt32(kCount, skinControllerData->getJointsCount());
+		inverseBindMatrices->setUnsignedInt32(kCount, (unsigned int)skinControllerData->getJointsCount());
         inverseBindMatrices->setUnsignedInt32(kByteOffset, 0);
         glTFSkin->extras()->setValue(kInverseBindMatrices, inverseBindMatrices);
 
         shared_ptr<GLTFOutputStream> animationOutputStream = this->_asset->createOutputStreamIfNeeded(this->_asset->getSharedBufferId());
-        inverseBindMatrices->setUnsignedInt32(kByteOffset,animationOutputStream->length());
+		inverseBindMatrices->setUnsignedInt32(kByteOffset, (unsigned int)animationOutputStream->length());
         shared_ptr<GLTFBuffer> buffer = glTFSkin->getInverseBindMatrices()->getBuffer();
         animationOutputStream->write(buffer);
 
@@ -1424,18 +1424,17 @@ namespace GLTF
                 glTFSkin->setSourceUID(skinController->getSource().toAscii());
 
                 unsigned int *remapTableForPositions = mesh->getRemapTableForPositions();
-                size_t vertexCount = mesh->getMeshAttributesForSemantic(GLTF::POSITION)[0]->getCount();
+                size_t vertexCount = mesh->getMeshAttribute(GLTF::POSITION, 0)->getCount();
                 //Now we remap the bone indices and weight attribute in respect of deindexing we have
 
                 shared_ptr<GLTFAccessor> weightsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getWeights(), vertexCount, remapTableForPositions, this->_asset->profile());
-                GLTF::IndexSetToMeshAttributeHashmap& weightsAttributes = mesh->getMeshAttributesForSemantic(GLTF::WEIGHT);
-                weightsAttributes[0] = weightsAttribute;
-                mesh->setMeshAttributesForSemantic(GLTF::WEIGHT, weightsAttributes);
+
+                mesh->setMeshAttribute(GLTF::WEIGHT, 0, weightsAttribute);
 
                 shared_ptr<GLTFAccessor> jointsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getJoints(), vertexCount, remapTableForPositions, this->_asset->profile());
-                GLTF::IndexSetToMeshAttributeHashmap& jointsAttributes = mesh->getMeshAttributesForSemantic(GLTF::JOINT);
-                jointsAttributes[0] = jointsAttribute;
-                mesh->setMeshAttributesForSemantic(GLTF::JOINT, jointsAttributes);
+
+                mesh->setMeshAttribute(GLTF::JOINT, 0, jointsAttribute);
+
 
                 GLTF::JSONValueVector primitives = mesh->getPrimitives()->values();
                 for (size_t i = 0 ; i < primitives.size() ; i++) {

converter/COLLADA2GLTF/GLTF/GLTFAccessor.cpp

@@ -88,15 +88,15 @@ namespace GLTF
     }
 
     void GLTFAccessor::setByteStride(size_t byteStride) {
-        this->setUnsignedInt32(kByteStride, byteStride);
+		this->setUnsignedInt32(kByteStride, (unsigned int)byteStride);
     }
 
     size_t GLTFAccessor::getByteStride() {
         return this->getUnsignedInt32(kByteStride);
     }
 
     void GLTFAccessor::setByteOffset(size_t byteOffset) {
-        this->setUnsignedInt32(kByteOffset, byteOffset);
+		this->setUnsignedInt32(kByteOffset, (unsigned int)byteOffset);
     }
 
     size_t GLTFAccessor::getByteOffset() {
@@ -108,7 +108,7 @@ namespace GLTF
     }
 
     void GLTFAccessor::setCount(size_t count) {
-        this->setUnsignedInt32(kCount, count);
+		this->setUnsignedInt32(kCount, (unsigned int)count);
     }
 
     const std::string& GLTFAccessor::getID() {

converter/COLLADA2GLTF/GLTF/GLTFAccessorCache.h

@@ -5,7 +5,7 @@
 
 namespace GLTF
 {
-    class GLTFAccessorCache
+	class GLTFAccessorCache
     {
     public:
         GLTFAccessorCache(void *pData, size_t length);

converter/COLLADA2GLTF/GLTF/GLTFAnimation.cpp

@@ -51,7 +51,7 @@ namespace GLTF
     }
 
     void GLTFAnimation::setCount(size_t count) {
-        this->setUnsignedInt32(kCount, count);
+		this->setUnsignedInt32(kCount, (unsigned int)count);
     }
 
     shared_ptr <JSONObject> GLTFAnimation::parameters() {

converter/COLLADA2GLTF/GLTF/GLTFAsset.cpp

@@ -59,7 +59,7 @@ namespace GLTF
         shared_ptr<GLTFAccessor> positionAttribute = mesh->getMeshAttribute(GLTF::POSITION, 0);
         size_t vertexCount = positionAttribute->getCount();
         unsigned int totalVerticesCount = asset->convertionResults()->getUnsignedInt32("verticesCount");
-        totalVerticesCount += vertexCount;
+		totalVerticesCount += (unsigned int)vertexCount;
         asset->convertionResults()->setUnsignedInt32("verticesCount", totalVerticesCount);
 
         for (unsigned int j = 0 ; j < allMeshAttributes->size() ; j++) {
@@ -86,7 +86,7 @@ namespace GLTF
         GLTFOutputStream* compressionOutputStream = asset->createOutputStreamIfNeeded(kCompressionOutputStream).get();
 
         shared_ptr <JSONObject> floatAttributeIndexMapping(new JSONObject());
-        unsigned compressedBufferStart = compressionOutputStream->length();
+		unsigned compressedBufferStart = (unsigned int)compressionOutputStream->length();
         encodeOpen3DGCMesh(mesh, floatAttributeIndexMapping, asset);
         typedef std::map<std::string , shared_ptr<GLTF::GLTFBuffer> > IDToBufferDef;
         IDToBufferDef IDToBuffer;
@@ -111,12 +111,12 @@ namespace GLTF
                 asset->convertionResults()->setUnsignedInt32("trianglesCount", trianglesCount);
                 size_t indicesLength = sizeof(unsigned short) * indicesCount;
                 uniqueIndices->setByteOffset(compressedBufferStart);
-                compressedBufferStart += indicesLength; //we simulate how will be the uncompressed data here, so this is the length in short *on purpose*
+				compressedBufferStart += (unsigned int)indicesLength; //we simulate how will be the uncompressed data here, so this is the length in short *on purpose*
             }
         }
 
         shared_ptr<GLTFAccessor> positionAttribute = mesh->getMeshAttribute(GLTF::POSITION, 0);
-        vertexCount = positionAttribute->getCount();
+		vertexCount = (unsigned int)positionAttribute->getCount();
         unsigned int totalVerticesCount = asset->convertionResults()->getUnsignedInt32("verticesCount");
         totalVerticesCount += vertexCount;
         asset->convertionResults()->setUnsignedInt32("verticesCount", totalVerticesCount);
@@ -131,7 +131,7 @@ namespace GLTF
             if (!IDToBuffer[bufferView->getBuffer()->getID()].get()) {
                 meshAttribute->exposeMinMax();
                 meshAttribute->setByteOffset(compressedBufferStart);
-                compressedBufferStart += buffer->getByteLength();
+				compressedBufferStart += (unsigned int)buffer->getByteLength();
                 IDToBuffer[bufferView->getBuffer()->getID()] = buffer;
             }
         }
@@ -533,13 +533,10 @@ namespace GLTF
             vector <GLTF::Semantic> allSemantics = mesh->allSemantics();
             for (size_t k = 0 ; k < allSemantics.size() ; k++) {
                 GLTF::Semantic semantic = allSemantics[k];
-                GLTF::IndexSetToMeshAttributeHashmap::const_iterator meshAttributeIterator;
-                GLTF::IndexSetToMeshAttributeHashmap& indexSetToMeshAttribute = mesh->getMeshAttributesForSemantic(semantic);
+                size_t attributesCount = mesh->getMeshAttributesCountForSemantic(semantic);
 
-                for (meshAttributeIterator = indexSetToMeshAttribute.begin() ; meshAttributeIterator != indexSetToMeshAttribute.end() ; meshAttributeIterator++) {
-                    //(*it).first;             // the key value (of type Key)
-                    //(*it).second;            // the mapped value (of type T)
-                    shared_ptr <GLTF::GLTFAccessor> meshAttribute = (*meshAttributeIterator).second;
+                for (size_t j = 0 ; j < attributesCount ; j++) {
+                    shared_ptr <GLTF::GLTFAccessor> meshAttribute = mesh->getMeshAttribute(semantic, j);
 
                     meshAttribute->setBufferView(isCompressed ? compressionBufferView : verticesBufferView);
                     accessors->setValue(meshAttribute->getID(), meshAttribute);
@@ -675,8 +672,8 @@ namespace GLTF
         if (sharedBuffer->getByteLength() == 0)
             remove(rawOutputStream->outputPathCStr());
 
-        this->convertionResults()->setUnsignedInt32(kGeometry, this->getGeometryByteLength());
-        this->convertionResults()->setUnsignedInt32(kAnimation, this->getAnimationByteLength());
+		this->convertionResults()->setUnsignedInt32(kGeometry, (unsigned int)this->getGeometryByteLength());
+		this->convertionResults()->setUnsignedInt32(kAnimation, (unsigned int)this->getAnimationByteLength());
         this->convertionResults()->setUnsignedInt32(kScene, (int) (verticesLength + indicesLength + animationLength + compressionLength) );
 
         this->log("[geometry] %d bytes\n", (int)this->getGeometryByteLength());

converter/COLLADA2GLTF/GLTF/GLTFAsset.h

@@ -42,7 +42,7 @@ namespace GLTF
 
     typedef std::map<std::string , shared_ptr<GLTFOutputStream> > NameToOutputStream;
 
-    class GLTFAsset
+	class GLTFAsset
     {
     public:
         GLTFAsset();

converter/COLLADA2GLTF/GLTF/GLTFBuffer.cpp

@@ -43,21 +43,21 @@ namespace GLTF
     _ID(ID),
     _data(0),
     _ownData(false) {
-        this->setUnsignedInt32(kByteLength, byteLength);
+		this->setUnsignedInt32(kByteLength, (unsigned int)byteLength);
     }
 
     GLTFBuffer::GLTFBuffer(void *data, size_t byteLength, bool ownData): JSONObject(),
     _data((unsigned char*)data),
     _ownData(ownData) {
-        this->setUnsignedInt32(kByteLength, byteLength);
+		this->setUnsignedInt32(kByteLength, (unsigned int)byteLength);
         this->_ID = GLTFUtils::generateIDForType("buffer");
     }
 
     GLTFBuffer::GLTFBuffer(std::string ID,void *data, size_t byteLength, bool ownData): JSONObject(),
     _ID(ID),
     _data((unsigned char*)data),
     _ownData(ownData) {
-        this->setUnsignedInt32(kByteLength, byteLength);
+		this->setUnsignedInt32(kByteLength, (unsigned int)byteLength);
     }
 
     void GLTFBuffer::evaluate(void* context) {
@@ -112,15 +112,15 @@ namespace GLTF
     }
 
     void GLTFBufferView::setByteLength(size_t byteLength) {
-        this->setUnsignedInt32(kByteLength, byteLength);
+		this->setUnsignedInt32(kByteLength, (unsigned int)byteLength);
     }
 
     size_t GLTFBufferView::getByteLength() {
         return this->getUnsignedInt32(kByteLength);
     }
 
     void GLTFBufferView::setByteOffset(size_t byteOffset) {
-        this->setUnsignedInt32(kByteOffset, byteOffset);
+		this->setUnsignedInt32(kByteOffset, (unsigned int)byteOffset);
     }
 
     size_t GLTFBufferView::getByteOffset() {

converter/COLLADA2GLTF/GLTF/GLTFMesh.cpp

@@ -60,14 +60,11 @@ namespace GLTF
         std::map<string, unsigned int> semanticAndSetToIndex;
 
         for (unsigned int i = 0 ; i < allSemantics.size() ; i++) {
-            IndexSetToMeshAttributeHashmap& indexSetToMeshAttribute = this->getMeshAttributesForSemantic(allSemantics[i]);
-            IndexSetToMeshAttributeHashmap::const_iterator meshAttributeIterator;
-            for (meshAttributeIterator = indexSetToMeshAttribute.begin() ; meshAttributeIterator != indexSetToMeshAttribute.end() ; meshAttributeIterator++) {
-                //(*it).first;             // the key value (of type Key)
-                //(*it).second;            // the mapped value (of type T)
-                shared_ptr <GLTF::GLTFAccessor> selectedMeshAttribute = (*meshAttributeIterator).second;
-                unsigned int indexSet = (*meshAttributeIterator).first;
-                GLTF::Semantic semantic = allSemantics[i];
+            GLTF::Semantic semantic = allSemantics[i];
+            size_t attributesCount = this->getMeshAttributesCountForSemantic(semantic);
+            for (size_t j = 0 ; j < attributesCount ; j++) {
+                shared_ptr <GLTF::GLTFAccessor> selectedMeshAttribute = this->getMeshAttribute(semantic, j);
+                unsigned int indexSet = j;
                 std::string semanticIndexSetKey = keyWithSemanticAndSet(semantic, indexSet);
                 unsigned int size = (unsigned int)meshAttributes->size();
                 semanticAndSetToIndex[semanticIndexSetKey] = size;
@@ -84,30 +81,22 @@ namespace GLTF
         return true;
     }
 
-    void GLTFMesh::setMeshAttributesForSemantic(GLTF::Semantic semantic, IndexSetToMeshAttributeHashmap& indexSetToMeshAttributeHashmap) {
-        this->_semanticToMeshAttributes[semantic] = indexSetToMeshAttributeHashmap;
-    }
-
     bool GLTFMesh::hasSemantic(Semantic semantic) {
         return this->_semanticToMeshAttributes.count(semantic) > 0;
     }
 
-    IndexSetToMeshAttributeHashmap& GLTFMesh::getMeshAttributesForSemantic(Semantic semantic) {
-        return this->_semanticToMeshAttributes[semantic];
-    }
-
     size_t GLTFMesh::getMeshAttributesCountForSemantic(Semantic semantic) {
         return this->_semanticToMeshAttributes[semantic].size();
     }
 
     shared_ptr<GLTFAccessor> GLTFMesh::getMeshAttribute(Semantic semantic, size_t indexOfSet) {
         IndexSetToMeshAttributeHashmap& hasmap = this->_semanticToMeshAttributes[semantic];
-        return hasmap[indexOfSet];
+		return hasmap[(unsigned int)indexOfSet];
     }
 
     void GLTFMesh::setMeshAttribute(Semantic semantic, size_t indexOfSet, shared_ptr<GLTFAccessor> meshAttribute) {
         IndexSetToMeshAttributeHashmap& hasmap = this->_semanticToMeshAttributes[semantic];
-        hasmap[indexOfSet] = meshAttribute;
+		hasmap[(unsigned int)indexOfSet] = meshAttribute;
     }
 
     vector <GLTF::Semantic> GLTFMesh::allSemantics() {
@@ -183,16 +172,16 @@ namespace GLTF
 
             size_t count = primitive->getVertexAttributesCount();
             for (size_t j = 0 ; j < count ; j++) {
-                GLTF::Semantic semantic = primitive->getSemanticAtIndex(j);
+				GLTF::Semantic semantic = primitive->getSemanticAtIndex((unsigned int)j);
                 std::string semanticAndSet = GLTFUtils::getStringForSemantic(semantic);
                 unsigned int indexOfSet = 0;
                 if ((semantic != GLTF::POSITION) && (semantic != GLTF::NORMAL) &&
                     //FIXME: should not be required for JOINT and WEIGHT
                     (semantic != GLTF::JOINT) && (semantic != GLTF::WEIGHT)) {
-                    indexOfSet = primitive->getIndexOfSetAtIndex(j);
+					indexOfSet = primitive->getIndexOfSetAtIndex((unsigned int)j);
                     semanticAndSet += "_" + GLTFUtils::toString(indexOfSet);
                 }
-                attributes->setString(semanticAndSet, this->getMeshAttributesForSemantic(semantic)[indexOfSet]->getID());
+                attributes->setString(semanticAndSet, this->getMeshAttribute(semantic, indexOfSet)->getID());
             }
 
             primitivesArray->appendValue(primitive);