{

std::string extension = GetExtension(pFile);

// fixme: are acc and ac3d *really* used? Some sources say they are

if(extension == "ac" || extension == "ac3d" || extension == "acc") {

return true;

}

if (!extension.length() || checkSig) {

uint32_t token = AI_MAKE_MAGIC("AC3D");

return CheckMagicToken(pIOHandler,pFile,&token,1,0);

}

return false;

{

SkipLine(&buffer);

return SkipSpaces(&buffer);

{

if (!TokenMatch(buffer,"OBJECT",6))

return;

SkipSpaces(&buffer);

++mNumMeshes;

objects.push_back(Object());

Object& obj = objects.back();

aiLight* light = NULL;

if (!ASSIMP_strincmp(buffer,"light",5))

{

// This is a light source. Add it to the list

mLights->push_back(light = new aiLight());

// Return a point light with no attenuation

light->mType = aiLightSource_POINT;

light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f,1.f,1.f);

light->mAttenuationConstant = 1.f;

// Generate a default name for both the light source and the node

// FIXME - what's the right way to print a size_t? Is 'zu' universally available? stick with the safe version.

light->mName.length = ::sprintf(light->mName.data,"ACLight_%i",static_cast<unsigned int>(mLights->size())-1);

obj.name = std::string( light->mName.data );

DefaultLogger::get()->debug("AC3D: Light source encountered");

obj.type = Object::Light;

}

else if (!ASSIMP_strincmp(buffer,"group",5))

{

obj.type = Object::Group;

}

else if (!ASSIMP_strincmp(buffer,"world",5))

{

obj.type = Object::World;

}

else obj.type = Object::Poly;

while (GetNextLine())

{

if (TokenMatch(buffer,"kids",4))

{

SkipSpaces(&buffer);

unsigned int num = strtoul10(buffer,&buffer);

GetNextLine();

if (num)

{

// load the children of this object recursively

obj.children.reserve(num);

for (unsigned int i = 0; i < num; ++i)

LoadObjectSection(obj.children);

}

return;

}

else if (TokenMatch(buffer,"name",4))

{

SkipSpaces(&buffer);

AI_AC_GET_STRING(obj.name);

// If this is a light source, we'll also need to store

// the name of the node in it.

if (light)

{

light->mName.Set(obj.name);

}

}

else if (TokenMatch(buffer,"texture",7))

{

SkipSpaces(&buffer);

AI_AC_GET_STRING(obj.texture);

}

else if (TokenMatch(buffer,"texrep",6))

{

SkipSpaces(&buffer);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texRepeat);

if (!obj.texRepeat.x || !obj.texRepeat.y)

obj.texRepeat = aiVector2D (1.f,1.f);

}

else if (TokenMatch(buffer,"texoff",6))

{

SkipSpaces(&buffer);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&obj.texOffset);

}

else if (TokenMatch(buffer,"rot",3))

{

SkipSpaces(&buffer);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,9,&obj.rotation);

}

else if (TokenMatch(buffer,"loc",3))

{

SkipSpaces(&buffer);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&obj.translation);

}

else if (TokenMatch(buffer,"subdiv",6))

{

SkipSpaces(&buffer);

obj.subDiv = strtoul10(buffer,&buffer);

}

else if (TokenMatch(buffer,"crease",6))

{

SkipSpaces(&buffer);

obj.crease = fast_atof(buffer);

}

else if (TokenMatch(buffer,"numvert",7))

{

SkipSpaces(&buffer);

unsigned int t = strtoul10(buffer,&buffer);

obj.vertices.reserve(t);

for (unsigned int i = 0; i < t;++i)

{

if (!GetNextLine())

{

DefaultLogger::get()->error("AC3D: Unexpected EOF: not all vertices have been parsed yet");

break;

}

else if (!IsNumeric(*buffer))

{

DefaultLogger::get()->error("AC3D: Unexpected token: not all vertices have been parsed yet");

--buffer; // make sure the line is processed a second time

break;

}

obj.vertices.push_back(aiVector3D());

aiVector3D& v = obj.vertices.back();

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,3,&v.x);

}

}

else if (TokenMatch(buffer,"numsurf",7))

{

SkipSpaces(&buffer);

bool Q3DWorkAround = false;

const unsigned int t = strtoul10(buffer,&buffer);

obj.surfaces.reserve(t);

for (unsigned int i = 0; i < t;++i)

{

GetNextLine();

if (!TokenMatch(buffer,"SURF",4))

{

// FIX: this can occur for some files - Quick 3D for

// example writes no surf chunks

if (!Q3DWorkAround)

{

DefaultLogger::get()->warn("AC3D: SURF token was expected");

DefaultLogger::get()->debug("Continuing with Quick3D Workaround enabled");

}

--buffer; // make sure the line is processed a second time

// break; --- see fix notes above

Q3DWorkAround = true;

}

SkipSpaces(&buffer);

obj.surfaces.push_back(Surface());

Surface& surf = obj.surfaces.back();

surf.flags = strtoul_cppstyle(buffer);

while (1)

{

if(!GetNextLine())

{

DefaultLogger::get()->error("AC3D: Unexpected EOF: surface is incomplete");

break;

}

if (TokenMatch(buffer,"mat",3))

{

SkipSpaces(&buffer);

surf.mat = strtoul10(buffer);

}

else if (TokenMatch(buffer,"refs",4))

{

// --- see fix notes above

if (Q3DWorkAround)

{

if (!surf.entries.empty())

{

buffer -= 6;

break;

}

}

SkipSpaces(&buffer);

const unsigned int m = strtoul10(buffer);

surf.entries.reserve(m);

obj.numRefs += m;

for (unsigned int k = 0; k < m; ++k)

{

if(!GetNextLine())

{

DefaultLogger::get()->error("AC3D: Unexpected EOF: surface references are incomplete");

break;

}

surf.entries.push_back(Surface::SurfaceEntry());

Surface::SurfaceEntry& entry = surf.entries.back();

entry.first = strtoul10(buffer,&buffer);

SkipSpaces(&buffer);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("",0,2,&entry.second);

}

}

else

{

--buffer; // make sure the line is processed a second time

break;

}

}

}

}

}

DefaultLogger::get()->error("AC3D: Unexpected EOF: \'kids\' line was expected");

const Material& matSrc,

aiMaterial& matDest)

{

aiString s;

if (matSrc.name.length())

{

s.Set(matSrc.name);

matDest.AddProperty(&s,AI_MATKEY_NAME);

}

if (object.texture.length())

{

s.Set(object.texture);

matDest.AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));

// UV transformation

if (1.f != object.texRepeat.x || 1.f != object.texRepeat.y ||

object.texOffset.x || object.texOffset.y)

{

aiUVTransform transform;

transform.mScaling = object.texRepeat;

transform.mTranslation = object.texOffset;

matDest.AddProperty(&transform,1,AI_MATKEY_UVTRANSFORM_DIFFUSE(0));

}

}

matDest.AddProperty<aiColor3D>(&matSrc.rgb,1, AI_MATKEY_COLOR_DIFFUSE);

matDest.AddProperty<aiColor3D>(&matSrc.amb,1, AI_MATKEY_COLOR_AMBIENT);

matDest.AddProperty<aiColor3D>(&matSrc.emis,1,AI_MATKEY_COLOR_EMISSIVE);

matDest.AddProperty<aiColor3D>(&matSrc.spec,1,AI_MATKEY_COLOR_SPECULAR);

int n;

if (matSrc.shin)

{

n = aiShadingMode_Phong;

matDest.AddProperty<float>(&matSrc.shin,1,AI_MATKEY_SHININESS);

}

else n = aiShadingMode_Gouraud;

matDest.AddProperty<int>(&n,1,AI_MATKEY_SHADING_MODEL);

float f = 1.f - matSrc.trans;

matDest.AddProperty<float>(&f,1,AI_MATKEY_OPACITY);

{

configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL,1) ? true : false;

configEvalSubdivision = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION,1) ? true : false;

aiScene* pScene, IOSystem* pIOHandler)

{

boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));

// Check whether we can read from the file

if( file.get() == NULL)

throw DeadlyImportError( "Failed to open AC3D file " + pFile + ".");

// allocate storage and copy the contents of the file to a memory buffer

std::vector<char> mBuffer2;

TextFileToBuffer(file.get(),mBuffer2);

buffer = &mBuffer2[0];

mNumMeshes = 0;

lights = polys = worlds = groups = 0;

if (::strncmp(buffer,"AC3D",4)) {

throw DeadlyImportError("AC3D: No valid AC3D file, magic sequence not found");

}

// print the file format version to the console

unsigned int version = HexDigitToDecimal( buffer[4] );

char msg[3];

ASSIMP_itoa10(msg,3,version);

DefaultLogger::get()->info(std::string("AC3D file format version: ") + msg);

std::vector<Material> materials;

materials.reserve(5);

std::vector<Object> rootObjects;

rootObjects.reserve(5);

std::vector<aiLight*> lights;

mLights = & lights;

while (GetNextLine())

{

if (TokenMatch(buffer,"MATERIAL",8))

{

materials.push_back(Material());

Material& mat = materials.back();

// manually parse the material ... sscanf would use the buldin atof ...

// Format: (name) rgb %f %f %f amb %f %f %f emis %f %f %f spec %f %f %f shi %d trans %f

AI_AC_SKIP_TO_NEXT_TOKEN();

if ('\"' == *buffer)

{

AI_AC_GET_STRING(mat.name);

AI_AC_SKIP_TO_NEXT_TOKEN();

}

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("rgb",3,3,&mat.rgb);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("amb",3,3,&mat.amb);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("emis",4,3,&mat.emis);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("spec",4,3,&mat.spec);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("shi",3,1,&mat.shin);

AI_AC_CHECKED_LOAD_FLOAT_ARRAY("trans",5,1,&mat.trans);

}

LoadObjectSection(rootObjects);

}

if (rootObjects.empty() || !mNumMeshes)

{

throw DeadlyImportError("AC3D: No meshes have been loaded");

}

if (materials.empty())

{

DefaultLogger::get()->warn("AC3D: No material has been found");

materials.push_back(Material());

}

mNumMeshes += (mNumMeshes>>2u) + 1;

std::vector<aiMesh*> meshes;

meshes.reserve(mNumMeshes);

std::vector<aiMaterial*> omaterials;

materials.reserve(mNumMeshes);

// generate a dummy root if there are multiple objects on the top layer

Object* root;

if (1 == rootObjects.size())

root = &rootObjects[0];

else

{

root = new Object();

}

// now convert the imported stuff to our output data structure

pScene->mRootNode = ConvertObjectSection(*root,meshes,omaterials,materials);

if (1 != rootObjects.size())delete root;

if (!::strncmp( pScene->mRootNode->mName.data, "Node", 4))

pScene->mRootNode->mName.Set("<AC3DWorld>");

// copy meshes

if (meshes.empty())

{

throw DeadlyImportError("An unknown error occured during converting");

}

pScene->mNumMeshes = (unsigned int)meshes.size();

pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];

::memcpy(pScene->mMeshes,&meshes[0],pScene->mNumMeshes*sizeof(void*));

// copy materials

pScene->mNumMaterials = (unsigned int)omaterials.size();

pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];

::memcpy(pScene->mMaterials,&omaterials[0],pScene->mNumMaterials*sizeof(void*));

// copy lights

pScene->mNumLights = (unsigned int)lights.size();

if (lights.size())

{

pScene->mLights = new aiLight*[lights.size()];

::memcpy(pScene->mLights,&lights[0],lights.size()*sizeof(void*));

}