void checkXml()
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
std::string inputDir = resourceManager->getLayoutPath();
std::string outputDir = resourceManager->getDataPath();
std::string outputFilePath = outputDir + SE_SEP + "checkxmlresult.txt";
FILE* f = fopen(outputFilePath.c_str(), "w");
if(!f)
{
LOGI("can not open output file : %s\n", outputFilePath.c_str());
return;
}
outputFile = f;
TCHAR inputDirWideChar[512];
memset(inputDirWideChar, 0, sizeof(TCHAR) * 512);
MultiByteToWideChar(CP_ACP, 0, inputDir.c_str(), -1, inputDirWideChar, 511);
DirWalk(inputDirWideChar, false);
std::string inputStr = inputDir;
std::list<_FileNameData>::iterator it ;
for(it = fileNameList.begin() ; it != fileNameList.end() ; it++)
{
_FileNameData fnd = *it;
std::string fileName = wcharToMultiByte(fnd.buf);
std::string filePath = fileName;
if(fileName != "")
{
handleContent(filePath.c_str());
}
}
fclose(f);
}
SE_MeshSimObject::~SE_MeshSimObject()
{
#ifdef USE_RUMANAGER
for(int i = 0; i < getSurfaceNum(); ++i)
{
std::string indexStr = SE_Util::intToString(i);
std::string renderUnitName = std::string(getName()) + "_" + indexStr;
std::string renderUnitName_img = std::string(getName()) + "_" + indexStr + "img";
std::string renderUnitName_mirr = std::string(getName()) + "_" + indexStr + "mirr";
SE_RenderUnitManager* srum = SE_Application::getInstance()->getRenderUnitManager();
srum->remove(renderUnitName.c_str());
srum->remove(renderUnitName_img.c_str());
srum->remove(renderUnitName_mirr.c_str());
}
#endif
//use unregister instead delete,mesh may be used by clone object
/*if(mOwnMesh == OWN)
{
delete mMesh;
} */
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
if(mMesh != NULL) {
SE_MeshID id = mMesh->getMeshID();
resourceManager->unregisterRes(SE_ResourceManager::OBJECT_MESH_RES, &id);
}
//SE_ImageDataID imageid = mSecondImageKey.c_str();
//resourceManager->unregisterRes(SE_ResourceManager::IMAGE_RES, &imageid);
}
bool SE_MeshSimObject::changeImageKey(const char* newKey)
{
#if 0
mSecondImageKey = newKey;
SE_ImageDataID id = newKey;
////id exist
//SE_TextureUnit* tu = this->getMesh()->getSurface(0)->getTexture()->getTextureUnit(0);
//
//SE_ImageDataID* imageDataIDArray = new SE_ImageDataID[1];
//imageDataIDArray[0] = id;
//tu->setImageDataID(imageDataIDArray,1);
SE_ResourceManager* rm = SE_Application::getInstance()->getResourceManager();
rm->registerRes(SE_ResourceManager::IMAGE_RES, &id);
if(rm->getImageData(id))
{
return true;
}
//id not exist,add it
rm->setImageData(id,NULL);
#endif
return false;
}
static void se_glReadPixels(JNIEnv *env, jobject obj, jstring imageKey, jint x, jint y, jint w, jint h) {
int width = w;
int height = h;
int rowBytes = w * 4;
int pixelFormat = SE_ImageData::RGBA;
int pixNum = width * height;
char* newData = (char *)malloc(height * rowBytes);
glReadPixels(
(GLint)x,
(GLint)y,
(GLsizei)width,
(GLsizei)height,
(GLenum)GL_RGBA,
(GLenum)GL_UNSIGNED_BYTE,
(GLvoid *)newData
);
const char* imageKey8 = env->GetStringUTFChars(imageKey, 0);
SE_ResourceManager *resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ImageData* newImgd = new SE_ImageData;
newImgd->setWidth(width);
newImgd->setHeight(height);
newImgd->setBytesPerRow(rowBytes);
newImgd->setPixelFormat(pixelFormat);
newImgd->setData(newData);
newImgd->setCompressType(SE_ImageData::RAW);
newImgd->setName(imageKey8);
resourceManager->insertPathImageData(imageKey8, newImgd, true);
env->ReleaseStringUTFChars(imageKey, imageKey8);
}
void SE_Image::setImageData(SE_RectPrimitive* primitive)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
int j = 0;
for(int i = 0 ; i < 5 ; i++)
{
SE_ImageUnit* imageUnit = mImageUnits[i].imageUnit;
if(imageUnit->isValid())
{
SE_ImageData* imageData = resourceManager->getImageData(imageUnit->imageDataID.getStr());
if(!imageData)
{
imageData = resourceManager->loadImage(imageUnit->imageDataID.getStr());
}
SE_ImageDataPortion dp;
dp.setX(imageUnit->imageRect.x);
dp.setY(imageUnit->imageRect.y);
dp.setWidth(imageUnit->imageRect.width);
dp.setHeight(imageUnit->imageRect.height);
primitive->setImageData(0, imageData, (SE_TEXUNIT_TYPE)j, NOT_OWN, dp);
j++;
mImageUnits[i].valid = 1;
}
}
}
static void handleContent(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_XMLTABLE_TYPE t = resourceManager->getXmlType(fileName);
switch(t)
{
case SE_ELEMENT_TABLE:
checkElementTable(fileName);
break;
case SE_IMAGE_TABLE:
checkImageTable(fileName);
break;
case SE_ACTION_TABLE:
checkActionTable(fileName);
break;
case SE_COLOREFFECT_TABLE:
checkColorEffectControllerTable(fileName);
break;
case SE_SEQUENCE_TABLE:
checkSequenceTable(fileName);
break;
case SE_STATE_TABLE:
break;
}
}
SE_MeshSimObject::SE_MeshSimObject(SE_Mesh* mesh, SE_OWN_TYPE ownMesh) : mMesh(NULL), mOwnMesh(NOT_OWN)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->registerRes(SE_ResourceManager::OBJECT_MESH_RES, &mMeshID);
mMesh = mesh;
mOwnMesh = ownMesh;
mSelected = false;
}
void SE_NetDataCommand::handle(SE_TimeMS realDelta, SE_TimeMS simulateDelta)
{
SE_ASSERT(mMsg->len >= 3);
int id = mMsg->data[0];
unsigned short dataLen = 0;
memcpy(&dataLen, mMsg->data + 1, 2);
dataLen = SE_Util::net2HostInt16(dataLen);
int realDataLen = dataLen - 3;
std::string str;
if(realDataLen > 0)
{
str.assign((char*)mMsg->data + 3, realDataLen);
}
for(int i = 0 ; i < mMsg->len ; i++)
{
LOGI("%d\n", mMsg->data[i]);
}
LOGI("### msg len = %d , str = %s ###\n", mMsg->len, str.c_str());
if(id == 0 && str.size() > 0)
{
SE_ImageUnit iu;
SE_ResourceManager* resourceManager = SE_GET_RESOURCEMANAGER();
SE_ImageData* imageData = resourceManager->loadImageWithFullPath(str.c_str());
if(!imageData)
{
LOGI("can not load image\n");
return;
}
iu.imageDataID = str.c_str();
iu.imageRect.x = 0;
iu.imageRect.y = 0;
iu.imageRect.width = imageData->getWidth();
iu.imageRect.height = imageData->getHeight();
SE_ImageElement* imageElement = new SE_ImageElement("");
imageElement->setBaseColor(iu);
SE_SceneManager* sceneManager = SE_Application::getInstance()->getSceneManager();
SE_Scene* scene = new SE_2DScene;
scene->setBackground(SE_Vector4f(1.0f, 1.0f, 1.0f, 1.0f));
scene->setBound(480, 800);
scene->setRootElement(imageElement);
SE_SceneID sceneID = sceneManager->add(scene);
//create camera
SE_Camera* camera = SE_Camera::create2DSceneCamera(480, 800);
SE_CameraManager* cameraManager = SE_Application::getInstance()->getCameraManager();
SE_CameraID cameraID = cameraManager->add(camera);
scene->setCamera(cameraID);
//end
sceneManager->show(sceneID);
}
else
{
}
}
static void checkStateTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadElementSchema(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, stateTableKeyword, sizeof(stateTableKeyword) / sizeof(const char*));
delete doc;
}
}
void visit(const SE_StringID& id, const SE_ImageItem* imageItem)
{
const SE_ImageItemProperty& imageItemProperty = imageItem->getProperty();
SE_ImageDataID imageDataID = imageItemProperty.getImageDataID();
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ImageData* imageData = resourceManager->loadImage(imageDataID.getStr());
if(!imageData)
{
OUTSTRING("... image file can not find : %s", imageDataID.getStr());
}
}
static void se_inflateResource(JNIEnv* env, jobject obj, jint resource, jstring objName, jint objIndex, jstring nodeName, jint nodeIndex, jboolean removeTopNode)
{
//Invoke by gl thread
jstring sceneName = (jstring)env->GetObjectField(obj, sceneNameID);
const char* sceneName8 = env->GetStringUTFChars(sceneName, 0);
const char* nodeName8 = env->GetStringUTFChars(nodeName, NULL);
const char* objName8 = env->GetStringUTFChars(objName, NULL);
SE_Scene* scene = SE_Application::getInstance()->getSceneManager()->getScene(SE_FRAMEBUFFER_SCENE, SE_StringID(sceneName8));
SE_Spatial* node = SE_Application::getInstance()->getSceneManager()->findSpatialByName(nodeName8, nodeIndex);
SE_Spatial* s = (SE_Spatial*)resource;
if (!node)
{
env->ReleaseStringUTFChars(sceneName, sceneName8);
env->ReleaseStringUTFChars(nodeName, nodeName8);
env->ReleaseStringUTFChars(objName, objName8);
return;
}
if (s) {
SE_ResourceManager* m = SE_Application::getInstance()->getResourceManager();
SE_ResourceManager* loader = s->getCBFLoader();
m->copy(loader);
s->deleteCBFLoader();
if (removeTopNode) {
s->getChildByIndex(0)->setSpatialName(objName8);
s->getChildByIndex(0)->setCloneIndex(objIndex);
s->replaceChildParent(node);
node->setCloneIndex(objIndex);
scene->inflate();
node->updateWorldTransform();
node->updateBoundingVolume();
node->updateWorldLayer();
delete s;
} else {
s->setSpatialName(objName8);
s->setCloneIndex(objIndex);
std::string modelName = objName8;
modelName = modelName + "_model";
s->getChildByIndex(0)->setSpatialName(modelName.c_str());
s->getChildByIndex(0)->setCloneIndex(objIndex);
scene->addSpatial(node, s);
scene->inflate();
node = scene->getRoot();
node->updateWorldTransform();
node->updateBoundingVolume();
node->updateWorldLayer();
}
}
env->ReleaseStringUTFChars(sceneName, sceneName8);
env->ReleaseStringUTFChars(nodeName, nodeName8);
env->ReleaseStringUTFChars(objName, objName8);
}
static TiXmlDocument* getDocument(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
std::string filePath = resourceManager->getLayoutPath() + SE_SEP + fileName;
TiXmlDocument* doc = new TiXmlDocument(filePath.c_str());
doc->LoadFile();
if(doc->Error() && doc->ErrorId() ==TiXmlBase::TIXML_ERROR_OPENING_FILE)
{
OUTSTRING("can not open xml file: %s\n", filePath);
return NULL;
}
return doc;
}
static jint se_loadResource(JNIEnv* env, jobject obj, jstring scenePath, jstring dataPath) {
//Invoke by load thread
//All resource will be insert in a loader,not resource manager
SE_ResourceManager* loader = new SE_ResourceManager();
const char* scenePath8 = env->GetStringUTFChars(scenePath, NULL);
const char* dataPath8 = env->GetStringUTFChars(dataPath, NULL);
SE_Spatial* s = loader->loadScene(scenePath8);
s->setCBFLoader(loader);
loader->loadBaseData(NULL, dataPath8);
env->ReleaseStringUTFChars(dataPath, dataPath8);
env->ReleaseStringUTFChars(scenePath, scenePath8);
return (int)s;
}
static void se_savePixelsData(JNIEnv *env, jobject obj, jstring savePath, jstring imageKey) {
const char* imageKey8 = env->GetStringUTFChars(imageKey, 0);
const char* savePath8 = env->GetStringUTFChars(savePath, 0);
SE_ImageDataID imageDataid(imageKey8);
SE_ResourceManager *resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ImageData* imgd = resourceManager->getImageData(imageDataid);
if (imgd) {
SE_File fbase(savePath8, SE_File::WRITE);
fbase.write(imgd->getData(), imgd->getHeight() * imgd->getBytesPerRow());
LOGI("SEHome:#################savePixelsData success!!!");
}
env->ReleaseStringUTFChars(imageKey, imageKey8);
env->ReleaseStringUTFChars(savePath, savePath8);
}
SE_ImageData* SE_Image::getImageData(const SE_ImageUnit& imageUnit)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ImageData* imageData = NULL;
if(imageUnit.isValid())
{
imageData = resourceManager->getImageData(imageUnit.imageDataID.getStr());
if(!imageData)
{
imageData = resourceManager->loadImage(imageUnit.imageDataID.getStr());
}
}
return imageData;
}
void SE_MeshSimObject::setMesh(SE_Mesh* mesh, SE_OWN_TYPE own)
{
//just for clone
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_MeshID id = mesh->getMeshID();
resourceManager->registerRes(SE_ResourceManager::OBJECT_MESH_RES, &id);
if(mMesh)
{
resourceManager->unregisterRes(SE_ResourceManager::OBJECT_MESH_RES, &mMeshID);
//delete mMesh;
}
mMesh = mesh;
}
void SE_ElementManager::load(SE_Element* parent, const char* filePath)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
std::string fileFullPath = std::string(resourceManager->getDataPath()) + "\\" + filePath;
TiXmlDocument doc(fileFullPath.c_str());
doc.LoadFile();
if(doc.Error() && doc.ErrorId() ==TiXmlBase::TIXML_ERROR_OPENING_FILE)
{
LOGI("can not open xml file: %s\n", filePath);
return;
}
handleXmlChild(parent, &doc);
}
static void checkSequenceTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadSequence(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, sequenceKeyword, sizeof(sequenceKeyword) / sizeof(const char*));
delete doc;
}
SequenceSetVisitor ssv;
ssv.sequenceSetID = fileName;
const SE_SequenceTable& sequenceTable = resourceManager->getSequenceTable();
sequenceTable.traverse(ssv);
}
static void checkElementTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadElementSchema(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, elementKeyword, sizeof(elementKeyword) / sizeof(const char*));
delete doc;
}
const SE_ElementSchemaTable& elementTable = resourceManager->getElementSchemaTable();
ElementMapVisitor emv;
emv.elementMapID = fileName;
elementTable.traverse(emv);
}
static void checkColorEffectControllerTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadElementSchema(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, colorEffectControllerKeyword, sizeof(colorEffectControllerKeyword) / sizeof(const char*));
delete doc;
}
const SE_ColorEffectControllerTable& colorEffectControllerTable = resourceManager->getColorEffectControllerTable();
ColorEffectControllerVisitor cecv;
cecv.colorEffectControllerID = fileName;
colorEffectControllerTable.traverse(cecv);
}
static void se_changeTextureImage(JNIEnv* env, jobject clazz,
jstring imageKey) {
const char* imagePath = env->GetStringUTFChars(imageKey, NULL);
SE_ResourceManager *resourceManager =
SE_Application::getInstance()->getResourceManager();
SE_ImageData* existdata = resourceManager->getImageDataFromPath(imagePath);
if (existdata && !existdata->getData()) {
GLuint texid = existdata->getTexID();
if (texid != 0) {
glDeleteTextures(1, &texid);
}
existdata->setTexID(0);
}
env->ReleaseStringUTFChars(imageKey, imagePath);
}
static jboolean se_loadPixelsData(JNIEnv *env, jobject obj, jstring savePath, jstring imageKey, jint w, jint h) {
const char* imageKey8 = env->GetStringUTFChars(imageKey, 0);
const char* savePath8 = env->GetStringUTFChars(savePath, 0);
SE_ImageDataID imageDataid(imageKey8);
SE_ResourceManager *resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ImageData* imgd = resourceManager->getImageData(imageDataid);
if (!imgd) {
char* data = NULL;
int len = 0;
SE_IO::readFileAll(savePath8, data, len);
if(len != 0) {
int power2Width = w;
int power2Height = h;
int pixelFormat = SE_ImageData::RGBA;
if(!SE_Util::isPower2(w))
{
power2Width = SE_Util::higherPower2(w);
}
if(!SE_Util::isPower2(h))
{
power2Height = SE_Util::higherPower2(h);
}
imgd = new SE_ImageData;
imgd->setWidth(power2Width);
imgd->setHeight(power2Height);
imgd->setBytesPerRow(power2Width * 4);
imgd->setPixelFormat(pixelFormat);
imgd->setData(data);
imgd->setCompressType(SE_ImageData::RAW);
imgd->setName(imageDataid.getStr());
//imgd->setPreWidth(w);
//imgd->setPreHeight(h);
resourceManager->insertPathImageData(imageDataid.getStr(), imgd);
resourceManager->setIdPath(imageDataid.getStr(),imageDataid.getStr());
}
}
env->ReleaseStringUTFChars(imageKey, imageKey8);
env->ReleaseStringUTFChars(savePath, savePath8);
if (!imgd)
{
return false;
}
return true;
}
static void checkImageTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadImageTable(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, imageTableKeyword, sizeof(imageTableKeyword) / sizeof(const char*));
delete doc;
}
const SE_ImageTable& imageTable = resourceManager->getImageTable();
ImageMapSetVisitor imv;
imv.imageMapSetID = fileName;
imageTable.traverse(imv);
if(!imv.findMapSet)
{
OUTSTRING("... %s image table file can not find", fileName);
}
}
SE_ImageData* SE_ColorEffectImage::createTextureElement(SE_Element* parent, SE_Image* img)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_ElementManager* elementManager = SE_Application::getInstance()->getElementManager();
SE_ImageData* imgData = resourceManager->getImageData(img->getUrl().c_str());
if(!imgData)
{
SE_ImageElement* e = new SE_ImageElement("");
elementManager->add(parent, e);
e->spawn();
imgData = new SE_ImageData;
SE_RenderTargetManager* renderTargetManager = SE_Application::getInstance()->getRenderTargetManager();
resourceManager->setImageData(img->getUrl().c_str(), imgData);
SE_RenderTarget* renderTarget = new SE_TextureTarget(imgData);
SE_RenderTargetID renderTargetID = renderTargetManager->add(renderTarget);
e->setRenderTargetID(renderTargetID);
}
return imgData;
}
static void checkActionTable(const char* fileName)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->loadAction(fileName);
TiXmlDocument* doc = getDocument(fileName);
if(doc)
{
checkDocument(fileName, doc, actionKeyword, sizeof(actionKeyword) / sizeof(const char*));
delete doc;
}
const SE_ActionTable& actionTable = resourceManager->getActionTable();
ActionSetVisitor asv;
asv.actionMapID = fileName;
actionTable.traverse(asv);
if(!asv.found)
{
OUTSTRING("... %s action table not found", fileName);
}
}
SE_MeshSimObject::SE_MeshSimObject(const SE_MeshID& meshID ) : mMesh(NULL), mOwnMesh(NOT_OWN)
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_MeshTransfer* meshTransfer = SE_Application::getInstance()->getResourceManager()->getMeshTransfer(meshID);
if(meshTransfer)
{
mMesh = meshTransfer->createMesh(SE_Application::getInstance()->getResourceManager());
mOwnMesh = OWN;
//insert object mesh to resource manager
resourceManager->setObjectMesh(meshID,mMesh);
resourceManager->registerRes(SE_ResourceManager::OBJECT_MESH_RES, &mMeshID);
resourceManager->registerRes(SE_ResourceManager::MESH_RES, &mMeshID);
}
mMeshID = meshID;
mSelected = false;
}
void SE_ShaderHandler::handle(SE_Element* parent, TiXmlElement* xmlElement, unsigned int indent)
{
if(!xmlElement)
return;
TiXmlAttribute* pAttribute = xmlElement->FirstAttribute();
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
std::string vertexShaderFilePath;
std::string fragmentShaderFilePath;
while(pAttribute)
{
const char* name = pAttribute->Name();
const char* value = pAttribute->Value();
if(!strcmp(name , "VertexShader"))
{
vertexShaderFilePath = std::string(resourceManager->getDataPath()) + SE_SEP + value;
}
else if(!strcmp(name, "FragmentShader"))
{
fragmentShaderFilePath = std::string(resourceManager->getDataPath()) + SE_SEP + value;
}
pAttribute = pAttribute->Next();
}
char* vertexShader;
char* fragmentShader;
int vertexShaderLen =0;
int fragmentShaderLen = 0;
SE_IO::readFileAll(vertexShaderFilePath.c_str(), vertexShader, vertexShaderLen);
SE_IO::readFileAll(fragmentShaderFilePath.c_str(), fragmentShader, fragmentShaderLen);
char* vs = new char[vertexShaderLen + 1];
char* fs = new char[fragmentShaderLen + 1];
memset(vs, 0, vertexShaderLen + 1);
memset(fs, 0, fragmentShaderLen + 1);
memcpy(vs, vertexShader, vertexShaderLen);
memcpy(fs, fragmentShader, fragmentShaderLen);
SE_ProgramDataID id("main_vertex_shader");
//resourceManager->setShaderProgram(id, vs, fs);
delete[] vertexShader;
delete[] fragmentShader;
}
static void checkResolvedURI(const std::string& uri)
{
SE_Util::SplitStringList strList = SE_Util::splitString(uri.c_str(), "/");
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
SE_XMLTABLE_TYPE t = resourceManager->getXmlType(strList[0].c_str());
switch(t)
{
case SE_ELEMENT_TABLE:
{
SE_ElementSchema* e = resourceManager->getElementSchema(uri.c_str());
if(!e)
{
OUTSTRING("... %s is not define in %s", uri.c_str(), strList[0].c_str());
}
}
break;
case SE_IMAGE_TABLE:
{
SE_ImageUnit iu = resourceManager->getImageUnit(uri.c_str());
if(!iu.isValid())
{
OUTSTRING("... %s is not defined in %s", uri.c_str(), strList[0].c_str());
}
}
break;
case SE_ACTION_TABLE:
{
SE_Action* a = resourceManager->getAction(uri.c_str());
if(!a)
{
OUTSTRING("... %s is not defined in %s", uri.c_str(), strList[0].c_str());
}
}
break;
case SE_SEQUENCE_TABLE:
{
SE_Sequence* s = resourceManager->getSequence(uri.c_str());
if(!s)
{
OUTSTRING("... %s is not defined in %s", uri.c_str(), strList[0].c_str());
}
}
break;
case SE_COLOREFFECT_TABLE:
{
SE_ColorEffectController* c = resourceManager->getColorEffectController(uri.c_str());
if(!c)
{
OUTSTRING("... %s is not defined in %s", uri.c_str(), strList[0].c_str());
}
}
break;
}
}
SE_RawImage::~SE_RawImage()
{
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
resourceManager->removeImageData(mImageDataID);
}
void SE_MeshSimObject::inflate()
{
SE_MeshTransfer* meshTransfer = SE_Application::getInstance()->getResourceManager()->getMeshTransfer(mMeshID);
if(!meshTransfer)
{
//mMeshID = SE_MeshID::INVALID;
if(SE_Application::getInstance()->SEHomeDebug)
LOGI("[%s] meshTransfer not found!!!!,mesh id is %s\n",this->getName(),mMeshID.getStr());
return;
}
if(mMesh)
{
//the object has inflated
return;
}
SE_ResourceManager* resourceManager = SE_Application::getInstance()->getResourceManager();
mMesh = meshTransfer->createMesh(SE_Application::getInstance()->getResourceManager());
if(mMesh)
{
resourceManager->setObjectMesh(mMeshID,mMesh);
mMesh->setMeshID(mMeshID);
resourceManager->registerRes(SE_ResourceManager::MESH_RES, &mMeshID);
resourceManager->registerRes(SE_ResourceManager::OBJECT_MESH_RES, &mMeshID);
mOwnMesh = OWN;
}
else
{
return;
}
SE_Geometry* sp = (SE_Geometry*)getSpatial();
if(!sp)
{
if(SE_Application::getInstance()->SEHomeDebug)
LOGI("Error !!!!Mesh simobject not attach to a spatial !!!!!!!!!\n");
}
bool mipmap = sp->isNeedGenerateMipMap();
if(!mipmap)
{
int num = this->getMesh()->getSurfaceNum();
for(int i = 0; i < num; ++i)
{
SE_Texture* tx = this->getMesh()->getSurface(i)->getTexture();
if(!tx)
{
continue;
}
int txnum = tx->getTexUnitNum();
for(int j = 0; j < txnum; ++j)
{
tx->getTextureUnit(j)->setSampleMin(LINEAR);
}
}
}
SE_Vector4f spatialData = sp->getEffectData();
int num = this->getMesh()->getSurfaceNum();
for(int i = 0; i < num; ++i)
{
this->getMesh()->getSurface(i)->getMaterialData()->shiny = spatialData.x;
this->getMesh()->getSurface(i)->getMaterialData()->shinessStrength = spatialData.y;
}
this->getSpatial()->applyLight();
}
