tools/a3dconvert/ObjLoader.cpp - platform/development - Git at Google

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "ObjLoader.h"
 #include <rsFileA3D.h>
 #include <sstream>

 ObjLoader::ObjLoader() :
     mPositionsStride(3), mNormalsStride(3), mTextureCoordsStride(2) {

 }

 bool isWhitespace(char c) {
     const char whiteSpace[] = { ' ', '\n', '\t', '\f', '\r' };
     const uint32_t numWhiteSpaceChars = 5;
     for (uint32_t i = 0; i < numWhiteSpaceChars; i ++) {
         if (whiteSpace[i] == c) {
             return true;
         }
     }
     return false;
 }

 void eatWhitespace(std::istream &is) {
     while(is.good() && isWhitespace(is.peek())) {
         is.get();
     }
 }

 bool getToken(std::istream &is, std::string &token) {
     eatWhitespace(is);
     token.clear();
     char c;
     while(is.good() && !isWhitespace(is.peek())) {
         c = is.get();
         if (is.good()){
             token += c;
         }
     }
     return token.size() > 0;
 }

 void appendDataFromStream(std::vector<float> &dataVec, uint32_t numFloats, std::istream &is) {
     std::string token;
     for (uint32_t i = 0; i < numFloats; i ++){
         bool valid = getToken(is, token);
         if (valid) {
             dataVec.push_back((float)atof(token.c_str()));
         } else {
             fprintf(stderr, "Encountered error reading geometry data");
             dataVec.push_back(0.0f);
         }
     }
 }

 bool checkNegativeIndex(int idx) {
     if(idx < 0) {
         fprintf(stderr, "Negative indices are not supported. Skipping face\n");
         return false;
     }
     return true;
 }

 void ObjLoader::parseRawFaces(){
     // We need at least a triangle
     if (mRawFaces.size() < 3) {
         return;
     }

     const char slash = '/';
     mParsedFaces.resize(mRawFaces.size());
     for (uint32_t i = 0; i < mRawFaces.size(); i ++) {
         size_t firstSeparator = mRawFaces[i].find_first_of(slash);
         size_t nextSeparator = mRawFaces[i].find_last_of(slash);

         // Use the string as a temp buffer to parse the index
         // Insert 0 instead of the slash to avoid substrings
         if (firstSeparator != std::string::npos) {
             mRawFaces[i][firstSeparator] = 0;
         }
         // Simple case, only one index
         int32_t vIdx = atoi(mRawFaces[i].c_str());
         // We do not support negative indices
         if (!checkNegativeIndex(vIdx)) {
             return;
         }
         // obj indices things beginning 1
         mParsedFaces[i].vertIdx = (uint32_t)vIdx - 1;

         if (nextSeparator != std::string::npos && nextSeparator != firstSeparator) {
             mRawFaces[i][nextSeparator] = 0;
             uint32_t nIdx = atoi(mRawFaces[i].c_str() + nextSeparator + 1);
             if (!checkNegativeIndex(nIdx)) {
                 return;
             }
             // obj indexes things beginning 1
             mParsedFaces[i].normIdx = (uint32_t)nIdx - 1;
         }

         // second case is where we have vertex and texture indices
         if (nextSeparator != std::string::npos &&
            (nextSeparator > firstSeparator + 1 || nextSeparator == firstSeparator)) {
             uint32_t tIdx = atoi(mRawFaces[i].c_str() + firstSeparator + 1);
             if (!checkNegativeIndex(tIdx)) {
                 return;
             }
             // obj indexes things beginning 1
             mParsedFaces[i].texIdx = (uint32_t)tIdx - 1;
         }
     }

     // Make sure a face list exists before we go adding to it
     if (mMeshes.back().mUnfilteredFaces.size() == 0) {
         mMeshes.back().appendUnfilteredFaces(mLastMtl);
     }

     // Now we have our parsed face, that we need to triangulate as necessary
     // Treat more complex polygons as fans.
     // This approach will only work only for convex polygons
     // but concave polygons need to be addressed elsewhere anyway
     for (uint32_t next = 1; next < mParsedFaces.size() - 1; next ++) {
         // push it to our current mesh
         mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[0]);
         mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[next]);
         mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[next + 1]);
     }
 }

 void ObjLoader::checkNewMeshCreation(std::string &newGroup) {
     // start a new mesh if we have some faces
     // accumulated on the current mesh.
     // It's possible to have multiple group statements
     // but we only care to actually start a new mesh
     // once we can have something we can draw on the previous one
     if (mMeshes.back().mUnfilteredFaces.size()) {
         mMeshes.push_back(ObjMesh());
     }

     mMeshes.back().mName = newGroup;
     printf("Converting vertex group: %s\n", newGroup.c_str());
 }

 void ObjLoader::handleObjLine(char *line) {
     const char* vtxToken    = "v";
     const char* normToken   = "vn";
     const char* texToken    = "vt";
     const char* groupToken  = "g";
     const char* mtlToken    = "usemtl";
     const char* faceToken   = "f";

     std::istringstream lineStream(line, std::istringstream::in);

     std::string token;
     bool valid = getToken(lineStream, token);
     if (!valid) {
         return;
     }

     if (token == vtxToken) {
         appendDataFromStream(mObjPositions, 3, lineStream);
     } else if (token == normToken) {
         appendDataFromStream(mObjNormals, 3, lineStream);
     } else if (token == texToken) {
         appendDataFromStream(mObjTextureCoords, 2, lineStream);
     } else if (token == groupToken) {
         valid = getToken(lineStream, token);
         checkNewMeshCreation(token);
     } else if (token == faceToken) {
         mRawFaces.clear();
         while(getToken(lineStream, token)) {
             mRawFaces.push_back(token);
         }
         parseRawFaces();
     }
     // Ignore materials for now
     else if (token == mtlToken) {
         valid = getToken(lineStream, token);
         mLastMtl = token;

         mMeshes.back().appendUnfilteredFaces(token);
     }
 }

 bool ObjLoader::init(const char *fileName) {

     std::ifstream ifs(fileName , std::ifstream::in);
     if (!ifs.good()) {
         fprintf(stderr, "Failed to read file %s.\n", fileName);
         return false;
     }

     mMeshes.clear();

     const uint32_t maxBufferSize = 2048;
     char *buffer = new char[maxBufferSize];

     mMeshes.push_back(ObjMesh());

     std::string token;
     bool isDone = false;
     while(!isDone) {
         ifs.getline(buffer, maxBufferSize);
         if (ifs.good() && ifs.gcount() > 0) {
             handleObjLine(buffer);
         } else {
             isDone = true;
         }
     }

     ifs.close();
     delete buffer;

     reIndexGeometry();

     return true;
 }

 void ObjLoader::reIndexGeometry() {
     // We want to know where each vertex lands
     mVertexRemap.resize(mObjPositions.size() / mPositionsStride);

     for (uint32_t m = 0; m < mMeshes.size(); m ++) {
         // clear the remap vector of old data
         for (uint32_t r = 0; r < mVertexRemap.size(); r ++) {
             mVertexRemap[r].clear();
         }

         for (uint32_t i = 0; i < mMeshes[m].mUnfilteredFaces.size(); i ++) {
             mMeshes[m].mTriangleLists[i].reserve(mMeshes[m].mUnfilteredFaces[i].size() * 2);
             for (uint32_t fI = 0; fI < mMeshes[m].mUnfilteredFaces[i].size(); fI ++) {
                 uint32_t newIndex = reIndexGeometryPrim(mMeshes[m], mMeshes[m].mUnfilteredFaces[i][fI]);
                 mMeshes[m].mTriangleLists[i].push_back(newIndex);
             }
         }
     }
 }

 uint32_t ObjLoader::reIndexGeometryPrim(ObjMesh &mesh, PrimitiveVtx &prim) {

     std::vector<float> &mPositions = mesh.mChannels[0].mData;
     std::vector<float> &mNormals = mesh.mChannels[1].mData;
     std::vector<float> &mTextureCoords = mesh.mChannels[2].mData;

     float posX = mObjPositions[prim.vertIdx * mPositionsStride + 0];
     float posY = mObjPositions[prim.vertIdx * mPositionsStride + 1];
     float posZ = mObjPositions[prim.vertIdx * mPositionsStride + 2];

     float normX = 0.0f;
     float normY = 0.0f;
     float normZ = 0.0f;
     if (prim.normIdx != MAX_INDEX) {
         normX = mObjNormals[prim.normIdx * mNormalsStride + 0];
         normY = mObjNormals[prim.normIdx * mNormalsStride + 1];
         normZ = mObjNormals[prim.normIdx * mNormalsStride + 2];
     }

     float texCoordX = 0.0f;
     float texCoordY = 0.0f;
     if (prim.texIdx != MAX_INDEX) {
         texCoordX = mObjTextureCoords[prim.texIdx * mTextureCoordsStride + 0];
         texCoordY = mObjTextureCoords[prim.texIdx * mTextureCoordsStride + 1];
     }

     std::vector<unsigned int> &ithRemapList = mVertexRemap[prim.vertIdx];
     // We may have some potential vertices we can reuse
     // loop over all the potential candidates and see if any match our guy
     for (unsigned int i = 0; i < ithRemapList.size(); i ++) {

         int ithRemap = ithRemapList[i];
         // compare existing vertex with the new one
         if (mPositions[ithRemap * mPositionsStride + 0] != posX ||
             mPositions[ithRemap * mPositionsStride + 1] != posY ||
             mPositions[ithRemap * mPositionsStride + 2] != posZ) {
             continue;
         }

         // Now go over normals
         if (prim.normIdx != MAX_INDEX) {
             if (mNormals[ithRemap * mNormalsStride + 0] != normX ||
                 mNormals[ithRemap * mNormalsStride + 1] != normY ||
                 mNormals[ithRemap * mNormalsStride + 2] != normZ) {
                 continue;
             }
         }

         // And texcoords
         if (prim.texIdx != MAX_INDEX) {
             if (mTextureCoords[ithRemap * mTextureCoordsStride + 0] != texCoordX ||
                 mTextureCoords[ithRemap * mTextureCoordsStride + 1] != texCoordY) {
                 continue;
             }
         }

         // If we got here the new vertex is identical to the one that we already stored
         return ithRemap;
     }

     // We did not encounter this vertex yet, store it and return its index
     mPositions.push_back(posX);
     mPositions.push_back(posY);
     mPositions.push_back(posZ);

     if (prim.normIdx != MAX_INDEX) {
         mNormals.push_back(normX);
         mNormals.push_back(normY);
         mNormals.push_back(normZ);
     }

     if (prim.texIdx != MAX_INDEX) {
         mTextureCoords.push_back(texCoordX);
         mTextureCoords.push_back(texCoordY);
     }

     // We need to remember this mapping. Since we are storing floats, not vec3's, need to
     // divide by position size to get the right index
     int currentVertexIndex = (mPositions.size()/mPositionsStride) - 1;
     ithRemapList.push_back(currentVertexIndex);

     return currentVertexIndex;
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "ObjLoader.h"
	#include <rsFileA3D.h>
	#include <sstream>

	ObjLoader::ObjLoader() :
	mPositionsStride(3), mNormalsStride(3), mTextureCoordsStride(2) {

	}

	bool isWhitespace(char c) {
	const char whiteSpace[] = { ' ', '\n', '\t', '\f', '\r' };
	const uint32_t numWhiteSpaceChars = 5;
	for (uint32_t i = 0; i < numWhiteSpaceChars; i ++) {
	if (whiteSpace[i] == c) {
	return true;
	}
	}
	return false;
	}

	void eatWhitespace(std::istream &is) {
	while(is.good() && isWhitespace(is.peek())) {
	is.get();
	}
	}

	bool getToken(std::istream &is, std::string &token) {
	eatWhitespace(is);
	token.clear();
	char c;
	while(is.good() && !isWhitespace(is.peek())) {
	c = is.get();
	if (is.good()){
	token += c;
	}
	}
	return token.size() > 0;
	}

	void appendDataFromStream(std::vector<float> &dataVec, uint32_t numFloats, std::istream &is) {
	std::string token;
	for (uint32_t i = 0; i < numFloats; i ++){
	bool valid = getToken(is, token);
	if (valid) {
	dataVec.push_back((float)atof(token.c_str()));
	} else {
	fprintf(stderr, "Encountered error reading geometry data");
	dataVec.push_back(0.0f);
	}
	}
	}

	bool checkNegativeIndex(int idx) {
	if(idx < 0) {
	fprintf(stderr, "Negative indices are not supported. Skipping face\n");
	return false;
	}
	return true;
	}

	void ObjLoader::parseRawFaces(){
	// We need at least a triangle
	if (mRawFaces.size() < 3) {
	return;
	}

	const char slash = '/';
	mParsedFaces.resize(mRawFaces.size());
	for (uint32_t i = 0; i < mRawFaces.size(); i ++) {
	size_t firstSeparator = mRawFaces[i].find_first_of(slash);
	size_t nextSeparator = mRawFaces[i].find_last_of(slash);

	// Use the string as a temp buffer to parse the index
	// Insert 0 instead of the slash to avoid substrings
	if (firstSeparator != std::string::npos) {
	mRawFaces[i][firstSeparator] = 0;
	}
	// Simple case, only one index
	int32_t vIdx = atoi(mRawFaces[i].c_str());
	// We do not support negative indices
	if (!checkNegativeIndex(vIdx)) {
	return;
	}
	// obj indices things beginning 1
	mParsedFaces[i].vertIdx = (uint32_t)vIdx - 1;

	if (nextSeparator != std::string::npos && nextSeparator != firstSeparator) {
	mRawFaces[i][nextSeparator] = 0;
	uint32_t nIdx = atoi(mRawFaces[i].c_str() + nextSeparator + 1);
	if (!checkNegativeIndex(nIdx)) {
	return;
	}
	// obj indexes things beginning 1
	mParsedFaces[i].normIdx = (uint32_t)nIdx - 1;
	}

	// second case is where we have vertex and texture indices
	if (nextSeparator != std::string::npos &&
	(nextSeparator > firstSeparator + 1 \|\| nextSeparator == firstSeparator)) {
	uint32_t tIdx = atoi(mRawFaces[i].c_str() + firstSeparator + 1);
	if (!checkNegativeIndex(tIdx)) {
	return;
	}
	// obj indexes things beginning 1
	mParsedFaces[i].texIdx = (uint32_t)tIdx - 1;
	}
	}

	// Make sure a face list exists before we go adding to it
	if (mMeshes.back().mUnfilteredFaces.size() == 0) {
	mMeshes.back().appendUnfilteredFaces(mLastMtl);
	}

	// Now we have our parsed face, that we need to triangulate as necessary
	// Treat more complex polygons as fans.
	// This approach will only work only for convex polygons
	// but concave polygons need to be addressed elsewhere anyway
	for (uint32_t next = 1; next < mParsedFaces.size() - 1; next ++) {
	// push it to our current mesh
	mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[0]);
	mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[next]);
	mMeshes.back().mUnfilteredFaces.back().push_back(mParsedFaces[next + 1]);
	}
	}

	void ObjLoader::checkNewMeshCreation(std::string &newGroup) {
	// start a new mesh if we have some faces
	// accumulated on the current mesh.
	// It's possible to have multiple group statements
	// but we only care to actually start a new mesh
	// once we can have something we can draw on the previous one
	if (mMeshes.back().mUnfilteredFaces.size()) {
	mMeshes.push_back(ObjMesh());
	}

	mMeshes.back().mName = newGroup;
	printf("Converting vertex group: %s\n", newGroup.c_str());
	}

	void ObjLoader::handleObjLine(char *line) {
	const char* vtxToken = "v";
	const char* normToken = "vn";
	const char* texToken = "vt";
	const char* groupToken = "g";
	const char* mtlToken = "usemtl";
	const char* faceToken = "f";

	std::istringstream lineStream(line, std::istringstream::in);

	std::string token;
	bool valid = getToken(lineStream, token);
	if (!valid) {
	return;
	}

	if (token == vtxToken) {
	appendDataFromStream(mObjPositions, 3, lineStream);
	} else if (token == normToken) {
	appendDataFromStream(mObjNormals, 3, lineStream);
	} else if (token == texToken) {
	appendDataFromStream(mObjTextureCoords, 2, lineStream);
	} else if (token == groupToken) {
	valid = getToken(lineStream, token);
	checkNewMeshCreation(token);
	} else if (token == faceToken) {
	mRawFaces.clear();
	while(getToken(lineStream, token)) {
	mRawFaces.push_back(token);
	}
	parseRawFaces();
	}
	// Ignore materials for now
	else if (token == mtlToken) {
	valid = getToken(lineStream, token);
	mLastMtl = token;

	mMeshes.back().appendUnfilteredFaces(token);
	}
	}

	bool ObjLoader::init(const char *fileName) {

	std::ifstream ifs(fileName , std::ifstream::in);
	if (!ifs.good()) {
	fprintf(stderr, "Failed to read file %s.\n", fileName);
	return false;
	}

	mMeshes.clear();

	const uint32_t maxBufferSize = 2048;
	char *buffer = new char[maxBufferSize];

	mMeshes.push_back(ObjMesh());

	std::string token;
	bool isDone = false;
	while(!isDone) {
	ifs.getline(buffer, maxBufferSize);
	if (ifs.good() && ifs.gcount() > 0) {
	handleObjLine(buffer);
	} else {
	isDone = true;
	}
	}

	ifs.close();
	delete buffer;

	reIndexGeometry();

	return true;
	}

	void ObjLoader::reIndexGeometry() {
	// We want to know where each vertex lands
	mVertexRemap.resize(mObjPositions.size() / mPositionsStride);

	for (uint32_t m = 0; m < mMeshes.size(); m ++) {
	// clear the remap vector of old data
	for (uint32_t r = 0; r < mVertexRemap.size(); r ++) {
	mVertexRemap[r].clear();
	}

	for (uint32_t i = 0; i < mMeshes[m].mUnfilteredFaces.size(); i ++) {
	mMeshes[m].mTriangleLists[i].reserve(mMeshes[m].mUnfilteredFaces[i].size() * 2);
	for (uint32_t fI = 0; fI < mMeshes[m].mUnfilteredFaces[i].size(); fI ++) {
	uint32_t newIndex = reIndexGeometryPrim(mMeshes[m], mMeshes[m].mUnfilteredFaces[i][fI]);
	mMeshes[m].mTriangleLists[i].push_back(newIndex);
	}
	}
	}
	}

	uint32_t ObjLoader::reIndexGeometryPrim(ObjMesh &mesh, PrimitiveVtx &prim) {

	std::vector<float> &mPositions = mesh.mChannels[0].mData;
	std::vector<float> &mNormals = mesh.mChannels[1].mData;
	std::vector<float> &mTextureCoords = mesh.mChannels[2].mData;

	float posX = mObjPositions[prim.vertIdx * mPositionsStride + 0];
	float posY = mObjPositions[prim.vertIdx * mPositionsStride + 1];
	float posZ = mObjPositions[prim.vertIdx * mPositionsStride + 2];

	float normX = 0.0f;
	float normY = 0.0f;
	float normZ = 0.0f;
	if (prim.normIdx != MAX_INDEX) {
	normX = mObjNormals[prim.normIdx * mNormalsStride + 0];
	normY = mObjNormals[prim.normIdx * mNormalsStride + 1];
	normZ = mObjNormals[prim.normIdx * mNormalsStride + 2];
	}

	float texCoordX = 0.0f;
	float texCoordY = 0.0f;
	if (prim.texIdx != MAX_INDEX) {
	texCoordX = mObjTextureCoords[prim.texIdx * mTextureCoordsStride + 0];
	texCoordY = mObjTextureCoords[prim.texIdx * mTextureCoordsStride + 1];
	}

	std::vector<unsigned int> &ithRemapList = mVertexRemap[prim.vertIdx];
	// We may have some potential vertices we can reuse
	// loop over all the potential candidates and see if any match our guy
	for (unsigned int i = 0; i < ithRemapList.size(); i ++) {

	int ithRemap = ithRemapList[i];
	// compare existing vertex with the new one
	if (mPositions[ithRemap * mPositionsStride + 0] != posX \|\|
	mPositions[ithRemap * mPositionsStride + 1] != posY \|\|
	mPositions[ithRemap * mPositionsStride + 2] != posZ) {
	continue;
	}

	// Now go over normals
	if (prim.normIdx != MAX_INDEX) {
	if (mNormals[ithRemap * mNormalsStride + 0] != normX \|\|
	mNormals[ithRemap * mNormalsStride + 1] != normY \|\|
	mNormals[ithRemap * mNormalsStride + 2] != normZ) {
	continue;
	}
	}

	// And texcoords
	if (prim.texIdx != MAX_INDEX) {
	if (mTextureCoords[ithRemap * mTextureCoordsStride + 0] != texCoordX \|\|
	mTextureCoords[ithRemap * mTextureCoordsStride + 1] != texCoordY) {
	continue;
	}
	}

	// If we got here the new vertex is identical to the one that we already stored
	return ithRemap;
	}

	// We did not encounter this vertex yet, store it and return its index
	mPositions.push_back(posX);
	mPositions.push_back(posY);
	mPositions.push_back(posZ);

	if (prim.normIdx != MAX_INDEX) {
	mNormals.push_back(normX);
	mNormals.push_back(normY);
	mNormals.push_back(normZ);
	}

	if (prim.texIdx != MAX_INDEX) {
	mTextureCoords.push_back(texCoordX);
	mTextureCoords.push_back(texCoordY);
	}

	// We need to remember this mapping. Since we are storing floats, not vec3's, need to
	// divide by position size to get the right index
	int currentVertexIndex = (mPositions.size()/mPositionsStride) - 1;
	ithRemapList.push_back(currentVertexIndex);

	return currentVertexIndex;
	}