void SE_NewGeometry::write(SE_BufferOutput& output)
{
output.writeString("SE_NewGeometry");
output.writeInt(mImplchild->children.size());
output.writeInt(mImpl->attachObject.size());
SE_NewGeometry::_Impl::SimObjectList::iterator it;
for(it = mImpl->attachObject.begin() ; it != mImpl->attachObject.end() ; it++)
{
SE_SimObject* obj = *it;
obj->write(output);
}
SE_Spatial::write(output);
}
void SE_CommonNode::write(SE_BufferOutput& output)
{
output.writeString("SE_CommonNode");
std::vector<SE_Spatial*> children = getChildren();
output.writeInt(children.size());
SE_Spatial::write(output);
/*
std::list<SE_Spatial*>::iterator it;
for(it = mImpl->children.begin() ; it != mImpl->children.end() ; it++)
{
SE_Spatial* s = *it;
s->write(output);
}
*/
}
void SE_StringID::write(SE_BufferOutput& output)
{
output.writeString(mStr.c_str());
}
void SE_MeshSimObject::write(SE_BufferOutput& output)
{
output.writeString("SE_MeshSimObject");
mMeshID.write(output);
SE_SimObject::write(output);
}
void SE_SimObject::write(SE_BufferOutput& output)
{
output.writeString(mName.c_str());
}
void SE_Layer::write(SE_BufferOutput& output)
{
output.writeString(mLayer.c_str());
}
void SE_Geometry::writeEffect(SE_BufferOutput& output)
{
SE_Spatial::writeEffect(output);
//save this spatial light status
if(this->isSpatialEffectHasAttribute(SE_SpatialAttribute::LIGHTING))
{
output.writeInt(1);//this spatial need lighting
//write light para
std::vector<SE_Light*> dirlight;
std::vector<SE_Light*> pointlight;
std::vector<SE_Light*> spotlight;
getCurrentAttachedSimObj()->getMesh()->getSurface(0)->getDirLights(dirlight);
getCurrentAttachedSimObj()->getMesh()->getSurface(0)->getPointLights(pointlight);
getCurrentAttachedSimObj()->getMesh()->getSurface(0)->getSpotLights(spotlight);
//write dir light
output.writeInt(dirlight.size()); //write dirlight count
for(int i = 0; i < dirlight.size(); ++i)
{
//write dir light info
SE_Light* light = dirlight[i];
SE_Vector3f dir = light->getLightDir();
std::string name = light->getLightName();
SE_Vector3f color = light->getLightColor();
float dirstrength = light->getDirLightStrength();
output.writeVector3f(dir);
output.writeString(name.c_str());
output.writeVector3f(color);
output.writeFloat(dirstrength);
}
//write point light
output.writeInt(pointlight.size()); //write point light count
for(int i = 0; i < pointlight.size(); ++i)
{
//write dir light info
SE_Light* light = pointlight[i];
SE_Vector3f pos = light->getLightPos();
float constAttr = light->getConstantAttenuation();
float linearAttr = light->getLinearAttenuation();
float quatAttr = light->getQuadraticAttenuation();
std::string name = light->getLightName();
SE_Vector3f color = light->getLightColor();
output.writeVector3f(pos);
output.writeFloat(constAttr);
output.writeFloat(linearAttr);
output.writeFloat(quatAttr);
output.writeString(name.c_str());
output.writeVector3f(color);
}
//write spot light
output.writeInt(spotlight.size()); //write spot light count
for(int i = 0; i < spotlight.size(); ++i)
{
//write dir light info
SE_Light* light = spotlight[i];
SE_Vector3f pos = light->getLightPos();
SE_Vector3f spotdir = light->getLightDir();
float constAttr = light->getConstantAttenuation();
float linearAttr = light->getLinearAttenuation();
float quatAttr = light->getQuadraticAttenuation();
float cutoff = light->getSpotLightCutOff();
float soptexp = light->getSpotLightExp();
std::string name = light->getLightName();
SE_Vector3f color = light->getLightColor();
output.writeVector3f(pos);
output.writeVector3f(spotdir);
output.writeFloat(constAttr);
output.writeFloat(linearAttr);
output.writeFloat(quatAttr);
output.writeFloat(cutoff);
output.writeFloat(soptexp);
output.writeString(name.c_str());
output.writeVector3f(color);
}
}
else
{
output.writeInt(0);//do not lighting
}
//write shadow generator status
if(this->isSpatialEffectHasAttribute(SE_SpatialAttribute::SHADOWGENERATOR))
{
if(SE_Application::getInstance()->SEHomeDebug)
LOGI("spatial[%s] is shadow generator!\n",getSpatialName());
output.writeInt(1);
SE_Camera* s = SE_Application::getInstance()->getHelperCamera(SE_SHADOWCAMERA);
SE_Vector3f loc = s->getLocation();
SE_Vector3f target = s->getTarget();
SE_Vector3f up = s->getUp();
float neara = s->getFrustum()->getNear();
float fara = s->getFrustum()->getFar();
float fov = s->getFovDegree();
output.writeVector3f(loc);
output.writeVector3f(target);
output.writeVector3f(up);
output.writeFloat(neara);
output.writeFloat(fara);
output.writeFloat(fov);
}
else
{
//do not generate shadow
output.writeInt(0);
}
//write shadow render status
if(this->isSpatialEffectHasAttribute(SE_SpatialAttribute::SHADOWRENDER))
{
if(SE_Application::getInstance()->SEHomeDebug)
LOGI("spatial[%s] is shadow render!\n",getSpatialName());
output.writeInt(1);
}
else
{
//do not render shadow
output.writeInt(0);
}
//write mirror generator
if(this->isSpatialEffectHasAttribute(SE_SpatialAttribute::MIRRORGENERATOR))
{
output.writeInt(1);
output.writeString(mMirrorInfo.c_str());
output.writeInt((int)mMirrorPlane);
}
else
{
output.writeInt(0);
}
//write mirror render
if(this->isSpatialEffectHasAttribute(SE_SpatialAttribute::MIRRORRENDER))
{
output.writeInt(1);
float alpha = this->getAlpha();
output.writeFloat(alpha);
}
else
{
output.writeInt(0);
}
//write mipmap info
if(mGenerateMipMap)
{
output.writeInt(1);
}
else
{
output.writeInt(0);
}
float alpha = this->getAlpha();
output.writeFloat(alpha);
SE_Vector4f mspatialData = this->getEffectData();
output.writeVector4f(mspatialData);
unsigned int effectstate = this->getEffectState();
output.writeInt(effectstate);
}
void ASE_Loader::Write(SE_BufferOutput& output, SE_BufferOutput& outScene, const char* shaderPath)
{
int materialNum = mSceneObject->mMats.size();
int numWhichHasSubmaterial = 0;
int materialRealNum = materialNum;
int i;
for(i = 0 ; i < materialNum ; i++)
{
ASE_Material* srcm = &mSceneObject->mMats[i];
materialRealNum += srcm->numsubmaterials;
if(srcm->numsubmaterials > 0)
{
numWhichHasSubmaterial++;
}
}
std::vector<_MaterialData> materialVector(materialRealNum);
std::vector<int> indexWhichHasSubmaterial(numWhichHasSubmaterial);
int l = 0;
int mi = 0;
for(i = 0 ; i < materialNum ; i++)
{
ASE_Material* srcm = &mSceneObject->mMats[i];
_MaterialData md;
md.subMaterialNum = srcm->numsubmaterials;
md.md = srcm->materialData;
materialVector[mi++] = md;
if(srcm->numsubmaterials > 0)
{
indexWhichHasSubmaterial[l++] = i;
}
}
std::vector<int>::iterator it;
for(it = indexWhichHasSubmaterial.begin() ; it != indexWhichHasSubmaterial.end() ; it++)
{
int index = *it;
ASE_Material* m = &mSceneObject->mMats[index];
for(int j = 0 ; j < m->numsubmaterials ; j++)
{
_MaterialData md;
md.subMaterialNum = 0;
md.md = m->submaterials[j];
materialVector[mi++] = md;
}
}
std::vector<_MaterialData>::iterator itMaterial;
output.writeShort(SE_MATERIALDATA_ID);
output.writeInt(materialVector.size());
int mmm = materialVector.size();
//for(itMaterial = materialVector.begin() ; itMaterial != materialVector.end() ; itMaterial++)
for(i = 0 ; i < materialVector.size() ; i++)
{
SE_MaterialDataID mid = SE_Application::getInstance()->createCommonID();
mid.print();
SE_Util::sleep(SLEEP_COUNT);
materialVector[i].mid = mid;
mid.write(output);
output.writeVector3f(materialVector[i].md.ambient);
output.writeVector3f(materialVector[i].md.diffuse);
output.writeVector3f(materialVector[i].md.specular);
output.writeVector3f(SE_Vector3f(0, 0, 0));
}
/////////////////////////////write texture data ///////////////
output.writeShort(SE_IMAGEDATA_ID);
int imageDataNum = 0;
for(itMaterial = materialVector.begin() ; itMaterial != materialVector.end() ; itMaterial++)
{
std::string texStr(itMaterial->md.texName);
if(texStr != "")
{
imageDataNum++;
}
}
output.writeInt(imageDataNum);
for(itMaterial = materialVector.begin() ; itMaterial != materialVector.end() ; itMaterial++)
{
std::string texStr(itMaterial->md.texName);
if(texStr != "")
{
size_t pos = texStr.find('.');
std::string name = texStr.substr(0, pos);
name = name + ".raw";
SE_ImageDataID tid = texStr.c_str();
itMaterial->tid = tid;
tid.write(output);
output.writeInt(0); // image data type
output.writeString(name.c_str());
}
}
/////////////////////////////write geom data /////////////////////////////////////////////
output.writeShort(SE_GEOMETRYDATA_ID);
int geomDataNum = mSceneObject->mGeomObjects.size();
output.writeInt(geomDataNum);
std::vector<_GeomTexCoordData> geomTexCoordData(geomDataNum);
std::list<ASE_GeometryObject*>::iterator itGeomObj;
int n = 0;
SE_Matrix4f modelToWorldM, worldToModelM;
SE_Matrix3f rotateM;
SE_Quat rotateQ;
SE_Vector3f rotateAxis, scale, translate;
for(itGeomObj = mSceneObject->mGeomObjects.begin();
itGeomObj != mSceneObject->mGeomObjects.end();
itGeomObj++)
{
ASE_GeometryObject* go = *itGeomObj;
ASE_Mesh* mesh = go->mesh;
SE_GeometryDataID gid = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
rotateAxis.x = go->rotateAxis[0];
rotateAxis.y = go->rotateAxis[1];
rotateAxis.z = go->rotateAxis[2];
scale.x = go->scale[0];
scale.y = go->scale[1];
scale.z = go->scale[2];
translate.x = go->translate[0];
translate.y = go->translate[1];
translate.z = go->translate[2];
rotateQ.set(go->rotateAngle, rotateAxis);
rotateM = rotateQ.toMatrix3f();//.setRotateFromAxis(go->rotateAngle, rotateAxis);
modelToWorldM.set(rotateM, scale, translate);
worldToModelM = modelToWorldM.inverse();
geomTexCoordData[n++].geomID = gid;
gid.write(output);
output.writeInt(mesh->numVertexes);
output.writeInt(mesh->numFaces);
output.writeInt(0);
int i;
for(i = 0 ; i < mesh->numVertexes ; i++)
{
SE_Vector4f p(mesh->vertexes[i].x, mesh->vertexes[i].y, mesh->vertexes[i].z, 1.0f);
p = worldToModelM.map(p);
output.writeFloat(p.x);
output.writeFloat(p.y);
output.writeFloat(p.z);
}
for(i = 0 ; i < mesh->numFaces ; i++)
{
output.writeInt(mesh->faces[i].vi[0]);
output.writeInt(mesh->faces[i].vi[1]);
output.writeInt(mesh->faces[i].vi[2]);
}
}
////////////////////////write texture coordinate///////////////////////////////////////////////
output.writeShort(SE_TEXCOORDDATA_ID);
output.writeInt(geomDataNum);
n = 0;
for(itGeomObj = mSceneObject->mGeomObjects.begin();
itGeomObj != mSceneObject->mGeomObjects.end();
itGeomObj++)
{
ASE_GeometryObject* go = *itGeomObj;
ASE_Mesh* mesh = go->mesh;
SE_TextureCoordDataID tcid = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
tcid.write(output);
geomTexCoordData[n++].texCoordID = tcid;
output.writeInt(mesh->numTVertexes);
output.writeInt(mesh->numFaces);
int i;
for(i = 0 ; i < mesh->numTVertexes ; i++)
{
output.writeFloat(mesh->tvertexes[i].s);
output.writeFloat(mesh->tvertexes[i].t);
}
for(i = 0 ; i < mesh->numFaces ; i++)
{
output.writeInt(mesh->tfaces[i].vi[0]);
output.writeInt(mesh->tfaces[i].vi[1]);
output.writeInt(mesh->tfaces[i].vi[2]);
}
}
///////////////////// write shader program ////
output.writeShort(SE_SHADERPROGRAMDATA_ID);
int spNum = 1;
output.writeInt(spNum);// shader program num;
std::vector<SE_ProgramDataID> programDataVector(spNum);
for(i = 0 ; i < spNum ; i++)
{
SE_ProgramDataID proID = "main_vertex_shader";
programDataVector[i] = proID;
SE_Util::sleep(SLEEP_COUNT);
proID.write(output);
std::string str(shaderPath);
std::string vertexShaderPath = str + SE_SEP + "main_vertex_shader.glsl";
std::string fragmentShaderPath = str + SE_SEP + "main_fragment_shader.glsl";
char* vertexShader = NULL;
int vertexShaderLen = 0;
char* fragmentShader = NULL;
int fragmentShaderLen = 0;
SE_IO::readFileAll(vertexShaderPath.c_str(), vertexShader, vertexShaderLen);
SE_IO::readFileAll(fragmentShaderPath.c_str(), fragmentShader, fragmentShaderLen);
output.writeInt(vertexShaderLen);
output.writeInt(fragmentShaderLen);
output.writeBytes(vertexShader, vertexShaderLen);
output.writeBytes(fragmentShader, fragmentShaderLen);
delete[] vertexShader;
delete[] fragmentShader;
}
///////////////////// write mesh ////////////////
std::vector<SE_MeshID> meshIDVector(geomDataNum);
output.writeShort(SE_MESHDATA_ID);
output.writeInt(geomDataNum);
n = 0;
for(itGeomObj = mSceneObject->mGeomObjects.begin();
itGeomObj != mSceneObject->mGeomObjects.end();
itGeomObj++)
{
ASE_GeometryObject* go = *itGeomObj;
ASE_Mesh* mesh = go->mesh;
SE_MeshID meshID = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
meshID.write(output);
meshIDVector[n] = meshID;
SE_GeometryDataID geomID = geomTexCoordData[n].geomID;
SE_TextureCoordDataID texCoordID = geomTexCoordData[n].texCoordID;
n++;
geomID.write(output);
output.writeFloat(go->wireframeColor[0]);
output.writeFloat(go->wireframeColor[1]);
output.writeFloat(go->wireframeColor[2]);
int texNum = 0;
int materialref = go->materialref;
int startpos = 0;
int subMaterialStartPos = 0;
_MaterialData mdData;
if(materialref == -1)
{
output.writeInt(texNum);
goto WRIET_SURFACE;
}
mdData = materialVector[materialref];
if(mdData.subMaterialNum > 0)
{
int j;
for(j = 0 ; j < (materialref - 1) ; j++)
{
_MaterialData d = materialVector[j];
startpos += d.subMaterialNum;
}
int k = startpos;
for(int j = 0 ; j < mdData.subMaterialNum ; j++)
{
_MaterialData subMaterialData = materialVector[materialNum + k];
k++;
std::string texStr(subMaterialData.md.texName);
if(texStr != "")
{
texNum++;
}
}
}
else
{
std::string texStr(mdData.md.texName);
if(texStr != "")
{
texNum = 1;
}
}
output.writeInt(texNum);
for(i = 0 ; i < texNum ; i++)
{
if(mdData.subMaterialNum > 0)
{
int j;
for(j = 0 ; j < (materialref - 1) ; j++)
{
_MaterialData d = materialVector[j];
subMaterialStartPos += d.subMaterialNum;
}
for(int j = 0 ; j < mdData.subMaterialNum ; j++)
{
_MaterialData subMaterialData = materialVector[materialNum + subMaterialStartPos];
subMaterialStartPos++;
std::string texStr(subMaterialData.md.texName);
if(texStr != "")
{
output.writeInt(1);//current we just has one texture unit;
output.writeInt(0);//texture unit type is TEXTURE0
texCoordID.write(output);
output.writeInt(1);//image num use in the texture unit. current it is not mipmap. so the num is 1
subMaterialData.tid.write(output);
}
}
}
else
{
std::string texStr(mdData.md.texName);
if(texStr != "")
{
output.writeInt(1);//current we just has one texture unit;
output.writeInt(0);//texture unit type is TEXTURE0
texCoordID.write(output);
output.writeInt(1);//image num use in the texture unit. current it is not mipmap. so the num is 1
mdData.tid.write(output);
}
}
}
///write surface
WRIET_SURFACE:
if(mesh->numFaceGroup > 0)
{
SE_ASSERT(mesh->numFaceGroup == mesh->faceGroup.size());
output.writeInt(mesh->numFaceGroup);
std::vector<std::list<int> >::iterator itFaceGroup;
int indexM = startpos;
int texIndex = 0;
for(itFaceGroup = mesh->faceGroup.begin() ; itFaceGroup != mesh->faceGroup.end(); itFaceGroup++)
{
_MaterialData md = materialVector[materialNum + indexM];
std::string texStr(md.md.texName);
md.mid.write(output);
output.writeInt(itFaceGroup->size());
std::list<int>::iterator itFace;
for(itFace = itFaceGroup->begin() ; itFace != itFaceGroup->end() ;
itFace++)
{
output.writeInt(*itFace);
}
programDataVector[0].write(output);
if(texStr != "")
{
output.writeInt(texIndex);
}
else
{
output.writeInt(-1);
}
indexM++;
texIndex++;
}
}
else
{
output.writeInt(1); //just has one surface
std::string texStr(mdData.md.texName);
mdData.mid.write(output);
output.writeInt(mesh->numFaces); // facets num;
for(int f = 0 ; f < mesh->numFaces ; f++)
output.writeInt(f);
programDataVector[0].write(output);
if(texStr != "")
{
output.writeInt(0); // the texture index is 0;
}
else
{
output.writeInt(-1);
}
}
}
/////// create scene //////////
SE_SpatialID spatialID = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
SE_CommonNode* rootNode = new SE_CommonNode(spatialID, NULL);
rootNode->setBVType(SE_BoundingVolume::AABB);
n = 0;
for(itGeomObj = mSceneObject->mGeomObjects.begin();
itGeomObj != mSceneObject->mGeomObjects.end();
itGeomObj++)
{
ASE_GeometryObject* go = *itGeomObj;
ASE_Mesh* mesh = go->mesh;
SE_MeshID meshID = meshIDVector[n++];
SE_SpatialID childID = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
SE_Geometry* child = new SE_Geometry(childID, rootNode);
rootNode->addChild(child);
SE_Vector3f translate, scale, rotateAxis;
translate.x = go->translate[0];
translate.y = go->translate[1];
translate.z = go->translate[2];
scale.x = go->scale[0];
scale.y = go->scale[1];
scale.z = go->scale[2];
rotateAxis.x = go->rotateAxis[0];
rotateAxis.y = go->rotateAxis[1];
rotateAxis.z = go->rotateAxis[2];
child->setLocalTranslate(translate);
//child->setLocalTranslate(SE_Vector3f(0, 0, 0));
child->setLocalScale(scale);
//child->setLocalScale(SE_Vector3f(1.0, 1.0, 1.0));
SE_Quat q;
q.set(go->rotateAngle, rotateAxis);
child->setLocalRotate(q);
//q.set(0, SE_Vector3f(0, 0, 0));
child->setBVType(SE_BoundingVolume::AABB);
SE_MeshSimObject* meshObj = new SE_MeshSimObject(meshID);
meshObj->setName(go->name);
child->attachSimObject(meshObj);
}
SE_SceneID sceneID = SE_Application::getInstance()->createCommonID();
SE_Util::sleep(SLEEP_COUNT);
sceneID.write(outScene);
_WriteSceneTravel wst(outScene);
rootNode->travel(&wst, true);
LOGI("write end\n");
}