bool OFTexturePaletteRecord::readTexAttr(TexAttr &attr) { bool returnValue = false; PathHandler *ph = ImageFileHandler::the()->getPathHandler(); if(ph != NULL) { std::string imgFile = szFilename; std::string attrFile = imgFile + ".attr"; attrFile = ph->findFile(attrFile.c_str()); if(attrFile.empty() == false) { OSG_OPENFLIGHT_LOG(("OFTexturePaletteRecord::readTexAttr: [%s]\n", attrFile.c_str())); std::ifstream ifs; ifs.open(attrFile.c_str(), std::ios::in | std::ios::binary); Inherited::readVal(ifs, attr.numTexelU); Inherited::readVal(ifs, attr.numTexelV); Inherited::readVal(ifs, attr.realSizeU); Inherited::readVal(ifs, attr.realSizeV); Inherited::readVal(ifs, attr.upX); Inherited::readVal(ifs, attr.upY); Inherited::readVal(ifs, attr.fileFormat); Inherited::readVal(ifs, attr.minFilter); Inherited::readVal(ifs, attr.magFilter); Inherited::readVal(ifs, attr.wrapUV); Inherited::readVal(ifs, attr.wrapU); Inherited::readVal(ifs, attr.wrapV); Inherited::readVal(ifs, attr.modified); Inherited::readVal(ifs, attr.pivotX); Inherited::readVal(ifs, attr.pivotY); Inherited::readVal(ifs, attr.envMode); if(attr.wrapU == 3) attr.wrapU = attr.wrapUV; if(attr.wrapV == 3) attr.wrapV = attr.wrapUV; returnValue = true; } } return returnValue; }
OSG_USING_NAMESPACE // Documentation for this class is emited in the // OSGProxyGroupBase.cpp file. // To modify it, please change the .fcd file (OSGProxyGroup.fcd) and // regenerate the base file. /*-------------------------------------------------------------------------*/ /* Sync */ void ProxyGroup::changed(ConstFieldMaskArg whichField, UInt32 origin, BitVector details) { if(whichField & (UrlFieldMask)) { if(getAbsoluteUrl().empty()) { PathHandler *ph = SceneFileHandler::the()->getPathHandler(); if(ph != NULL) { setAbsoluteUrl(ph->findFile(getUrl().c_str())); } if(getAbsoluteUrl().empty()) { setAbsoluteUrl(getUrl()); } setState(NOT_LOADED); } } if(whichField & (StateFieldMask | UrlFieldMask | VolumeFieldMask)) { for(UInt32 i = 0; i < _mfParents.size(); i++) { _mfParents[i]->invalidateVolume(); } } Inherited::changed(whichField, origin, details); }
Int32 OBJSceneFileType::readMTL ( const Char8 *fileName, std::map<std::string, SimpleTexturedMaterialUnrecPtr> & mtlMap ) const { if(fileName == NULL || strlen(fileName) == 0) return 0; Int32 mtlCount = 0; PathHandler *pathHandler = SceneFileHandler::the()->getPathHandler(); std::string fullFilePath; if(pathHandler != NULL) fullFilePath = pathHandler->findFile(fileName); else fullFilePath = fileName; if(fullFilePath.empty()) { FWARNING (("Couldn't open '%s'!\n", fileName)); return 0; } std::ifstream in(fullFilePath.c_str()); SimpleTexturedMaterialUnrecPtr mtlPtr = NULL; Real32 a,b,c; std::string elem; std::map<std::string, MaterialElem>::const_iterator elemI; MaterialElem mtlElem; std::map<std::string, OSG::ImageUnrecPtr> imageMap; std::map<std::string, OSG::ImageUnrecPtr>::iterator iI; ImageUnrecPtr image = NULL; bool constDiffuse = false, constAmbient = false, constSpecular = false; if (in) { for (in >> elem; in.eof() == false; in >> elem) { if (elem[0] == '#' || elem[0] == '$' ) { in.ignore(INT_MAX, '\n'); } else { elemI = _mtlElemMap.find(elem); mtlElem = ((elemI == _mtlElemMap.end()) ? UNKNOWN_ME : elemI->second); if (mtlElem == NEW_MTL_ME) { in >> elem; mtlPtr = SimpleTexturedMaterial::create(); mtlPtr->setColorMaterial(GL_NONE); mtlPtr->setEnvMode(GL_MODULATE); mtlMap[elem] = mtlPtr; mtlCount++; constDiffuse = false; constAmbient = false; constSpecular = false; } else { if (mtlPtr == NULL) { FFATAL (( "Invalid Mtl token: %s, newmtl expected in %s\n", elem.c_str(), fileName )); in.ignore(INT_MAX, '\n'); } else { switch (mtlElem) { case MTL_DIFFUSE_ME: in >> a >> b >> c; if (!constDiffuse) mtlPtr->setDiffuse( Color3f( a,b,c )); break; case MTL_AMBIENT_ME: in >> a >> b >> c; if (!constAmbient) mtlPtr->setAmbient( Color3f( a,b,c )); break; case MTL_SPECULAR_ME: in >> a >> b >> c; if (!constSpecular) mtlPtr->setSpecular( Color3f( a,b,c )); break; case MTL_SHININESS_ME: in >> a; mtlPtr->setShininess(a); break; case MTL_ILLUM_ME: ; // TODO: What to do with illum ?!? in >> elem; // FFATAL (("obj mtl illum not handled yet\n")); break; case MTL_REFL_ME: mtlPtr->setEnvMap(true); break; case MTL_TRANSPARENCY_ME: in >> a; mtlPtr->setTransparency(a); break; case MTL_DISSOLVE_ME: in >> a; mtlPtr->setTransparency(1.f - a); break; case MTL_MAP_KD_ME: case MTL_MAP_KA_ME: case MTL_MAP_KS_ME: image = NULL; in >> elem; iI = imageMap.find(elem); if (iI == imageMap.end()) { std::string fullElemPath; if(pathHandler != NULL) fullElemPath = pathHandler->findFile(elem.c_str()); else fullElemPath = elem.c_str(); image = OSG::ImageFileHandler::the()->read(fullElemPath.c_str()); if(image != NULL) { image->setForceAlphaBinary( image->calcIsAlphaBinary()); imageMap[elem] = image; } } else { image = iI->second; } if (image != NULL) { mtlPtr->setImage(image); switch (mtlElem) { case MTL_MAP_KD_ME: constDiffuse = true; mtlPtr->setDiffuse ( Color3f( 1.f, 1.f, 1.f) ); break; case MTL_MAP_KA_ME: constAmbient = true; mtlPtr->setAmbient ( Color3f( 1.f, 1.f, 1.f) ); break; case MTL_MAP_KS_ME: constSpecular = true; mtlPtr->setSpecular ( Color3f( 1.f, 1.f, 1.f) ); break; default: break; } } else { FFATAL (( "Can not find %s texture file in mtl %s \n", elem.c_str(), fileName )); } break; default: FWARNING (( "Invalid %s entry in %s\n", elem.c_str(), fileName )); in.ignore(INT_MAX, '\n'); } } } } }
void CharacterModel::convertMaterials(std::string configfile) { getMaterials().clear(); UInt32 mcnt = 0; PathHandler ph; ph.setBaseFile(configfile.c_str()); for(int mid = 0; mid < _coreModel->getCoreMaterialCount(); mid++) { CalCoreMaterial *coremat = _coreModel->getCoreMaterial(mid); SimpleMaterialPtr mat = SimpleMaterial::create(); beginEditCP(mat); CalCoreMaterial::Color &calamb = coremat->getAmbientColor(); CalCoreMaterial::Color &caldif = coremat->getDiffuseColor(); CalCoreMaterial::Color &calspec = coremat->getSpecularColor(); mat->setAmbient(Color3f(calamb.red / 255.0f, calamb.green / 255.0f, calamb.blue / 255.0f)); mat->setDiffuse(Color3f(caldif.red / 255.0f, caldif.green / 255.0f, caldif.blue / 255.0f)); mat->setSpecular(Color3f(calspec.red / 255.0f, calspec.green / 255.0f, calspec.blue / 255.0f)); mat->setShininess(coremat->getShininess() * 100.f); mat->setLit(true); mat->setColorMaterial(GL_NONE); for(int mapId = 0; mapId < coremat->getMapCount(); mapId++) { std::string file = coremat->getMapFilename(mapId); std::string pfile = ph.findFile(file.c_str()); SINFO << "Loading texture '" << pfile << "'..." << endLog; ImagePtr img = Image::create(); if(!img->read(pfile.c_str())) { SWARNING << "CharacterModel::convertMaterials: error " << "loading image " << file << endLog; } else { // amz with my test scene paladin.cfg all textures were // upside down so I disabled the vertical flipping perhaps // they fixed the bug in Cal3D? #if 0 beginEditCP(img); { // For some reason Cal3D expects textures upside down ??? UInt32 bpl = img->getBpp() * img->getWidth(); UChar8 *t = img->getData(), *b = t + (img->getHeight() - 1) * bpl, dum; for(UInt32 y = img->getHeight() / 2; y > 0; --y) { for(UInt32 x = bpl; x > 0; --x, ++t, ++b) { dum = *t; *t = *b; *b = dum; } b -= bpl * 2; } } endEditCP(img); #endif TextureChunkPtr tex = TextureChunk::create(); beginEditCP(tex); tex->setImage(img); tex->setEnvMode(GL_MODULATE); endEditCP(tex); mat->addChunk(tex); } } endEditCP(mat); coremat->setUserData((Cal::UserData)mcnt); getMaterials().push_back(mat); mcnt ++; } }
CalCoreModel *CharacterModel::loadConfig(std::string filename) { PathHandler ph; std::string pfile; ph.setBaseFile(filename.c_str()); // open the model configuration file std::ifstream file; file.open(filename.c_str(), std::ios::in | std::ios::binary); if(!file) { SWARNING << "Failed to open model configuration file '" << filename << "'." << endLog; return NULL; } CalCoreModel *model = new CalCoreModel("dummy"); // parse all lines from the model configuration file int line; for(line = 1; ; line++) { // read the next model configuration line std::string strBuffer; std::getline(file, strBuffer); // stop if we reached the end of file if(file.eof()) break; // check if an error happend while reading from the file if(!file) { SWARNING << "Error while reading from the model configuration file '" << filename << "'." << endLog; return NULL; } // find the first non-whitespace character std::string::size_type pos; pos = strBuffer.find_first_not_of(" \t"); // check for empty lines if((pos == std::string::npos) || (strBuffer[pos] == '\n') || (strBuffer[pos] == '\r') || (strBuffer[pos] == 0)) continue; // check for comment lines if(strBuffer[pos] == '#') continue; // get the key std::string strKey; strKey = strBuffer.substr(pos, strBuffer.find_first_of(" =\t\n\r", pos) - pos); pos += strKey.size(); // get the '=' character pos = strBuffer.find_first_not_of(" \t", pos); if((pos == std::string::npos) || (strBuffer[pos] != '=')) { SWARNING << filename << "(" << line << "): Invalid syntax." << endLog; return false; } // find the first non-whitespace character after the '=' character pos = strBuffer.find_first_not_of(" \t", pos + 1); // get the data std::string strData; strData = strBuffer.substr(pos, strBuffer.find_first_of("\n\r", pos) - pos); // handle the model creation if(strKey == "scale") { // set rendering scale factor //m_scale = atof(strData.c_str()); } else if(strKey == "skeleton") { pfile = ph.findFile(strData.c_str()); // load core skeleton SINFO << "Loading skeleton '" << pfile << "'..." << endLog; if(!model->loadCoreSkeleton(pfile.c_str())) { CalError::printLastError(); return false; } } else if(strKey == "animation") { pfile = ph.findFile(strData.c_str()); // load core animation SINFO << "Loading animation '" << pfile << "'..." << endLog; if(model->loadCoreAnimation(pfile.c_str()) == -1) { CalError::printLastError(); return false; } } else if(strKey == "mesh") { pfile = ph.findFile(strData.c_str()); // load core mesh SINFO << "Loading mesh '" << pfile << "'..." << endLog; if(model->loadCoreMesh(pfile.c_str()) == -1) { CalError::printLastError(); return false; } } else if(strKey == "material") { pfile = ph.findFile(strData.c_str()); // load core material SINFO << "Loading material '" << pfile << "'..." << endLog; if(model->loadCoreMaterial(pfile.c_str()) == -1) { CalError::printLastError(); return false; } } else { // everything else triggers an error message, but is ignored SWARNING << filename << "(" << line << "): Invalid syntax." << endLog; } } // create material threads int mid; for(mid = 0; mid < model->getCoreMaterialCount(); mid++) { model->createCoreMaterialThread(mid); model->setCoreMaterialId(mid, 0, mid); } file.close(); return model; }
bool DATImageFileType::read( Image *image, const Char8 *fileName) { bool retCode = false; std::ifstream inDat(fileName), inVolS; std::istream *inVol; std::string keyStr, objectFileName; const UInt32 lineBufferSize = 1024; Char8 *value, *keySepPos, lineBuffer[lineBufferSize]; const Char8 keySep = ':'; int fileOffset, keyL, valueL; std::map<std::string, KeyType>::iterator keyI; std::map<std::string, FormatDesc>::iterator formatI; KeyType key; Image::Type formatType; UInt32 channel = 1; UInt32 res[3]; UInt32 dataSize = 0; Image::PixelFormat pixelFormat = Image::OSG_L_PF; char *dataBuffer = 0; bool needConversion = false; // default endian type is big endian bool big_endian = true; res[0] = res[1] = res[2] = 0; fileOffset = 0; formatType = Image::OSG_INVALID_IMAGEDATATYPE; dataSize = 0; dataBuffer = 0; initTypeMap(); // read the data file for(lineBuffer[0] = 0; inDat.getline(lineBuffer, lineBufferSize); lineBuffer[0] = 0) { if((keySepPos = strchr(lineBuffer,keySep))) { keyL = keySepPos - lineBuffer; keyStr.assign( lineBuffer, keyL ); keyI = _keyStrMap.find(keyStr); key = ((keyI == _keyStrMap.end()) ? UNKNOWN_KT : keyI->second); value = keySepPos + 1; while (value && isspace(*value)) value++; valueL = int(strlen(value)); while (isspace(value[valueL-1])) value[--valueL] = 0; switch (key) { case OBJECT_FILE_NAME_KT: objectFileName = value; image->setAttachmentField ( keyStr, value ); break; case CHANNEL_KT: sscanf ( value, "%u", &(channel) ); image->setAttachmentField ( keyStr, value ); break; case RESOLUTION_KT: sscanf ( value, "%u %u %u", &(res[0]), &(res[1]), &(res[2])); image->setAttachmentField ( keyStr, value ); break; case FORMAT_KT: formatI = _formatStrMap.find(value); if (formatI != _formatStrMap.end()) { formatType = formatI->second.type; } else { formatType = Image::OSG_INVALID_IMAGEDATATYPE; } image->setAttachmentField ( keyStr, value ); break; case ENDIAN_KT: if(!strcmp(value, "LITTLE")) big_endian = false; image->setAttachmentField ( keyStr, value ); break; case FILE_OFFSET_KT: sscanf ( value, "%d", &fileOffset ); image->setAttachmentField ( keyStr, value ); break; case UNKNOWN_KT: FNOTICE (( "Uknown DAT file key: >%s<\n", keyStr.c_str() )); image->setAttachmentField ( keyStr, value ); break; case SLICE_THICKNESS_KT: default: image->setAttachmentField ( keyStr, value ); break; } } else { FINFO (("Skip DAT line\n")); } } // set pixelformat switch (channel) { case 4: pixelFormat = Image::OSG_RGBA_PF; break; case 3: pixelFormat = Image::OSG_RGB_PF; break; case 2: pixelFormat = Image::OSG_LA_PF; break; default: pixelFormat = Image::OSG_L_PF; break; } // check the setting and read the raw vol data if (objectFileName.empty() == false) { if((res[0] > 0) && (res[1] > 0) && (res[2] > 0)) { if(formatType != Image::OSG_INVALID_IMAGEDATATYPE) { inVolS.open(objectFileName.c_str(), std::ios::in | std::ios::binary); if (inVolS.fail() && ImageFileHandler::the()->getPathHandler()) { // Try to find the file in the search path inVolS.clear(); // reset the error state PathHandler *ph = ImageFileHandler::the()->getPathHandler(); inVolS.open(ph->findFile(objectFileName.c_str()).c_str(), std::ios::in | std::ios::binary ); } if(inVolS.fail()) { // Maybe compressed and name not changed? std::string gzname = objectFileName + ".gz"; inVolS.clear(); // reset the error state inVolS.open(gzname.c_str(), std::ios::in | std::ios::binary ); if(inVolS.fail() && ImageFileHandler::the()->getPathHandler()) { // Try to find the file in the search path inVolS.clear(); // reset the error state PathHandler *ph = ImageFileHandler::the()->getPathHandler(); inVolS.open(ph->findFile(gzname.c_str()).c_str(), std::ios::in | std::ios::binary ); } } if(inVolS.good()) { #ifdef OSG_WITH_ZLIB zip_istream *unzipper = NULL; #endif image->set(pixelFormat, res[0], res[1], res[2], 1, 1, 0.0, 0, formatType); image->clear(); dataSize = image->getSize(); UInt32 fileDataSize = dataSize; if(isGZip(inVolS)) { #ifdef OSG_WITH_ZLIB unzipper = new zip_istream(inVolS); inVol = unzipper; #else SFATAL << "Compressed streams are not supported! " << "Configure with --enable-png " << "--with-png=DIR options." << std::endl; #endif } else { inVol = &inVolS; // get length of the stream. inVol->seekg(0, std::ios::end); UInt64 length = inVol->tellg(); inVol->seekg(0, std::ios::beg); if(length < dataSize - fileOffset) { // correct dataSize. fileDataSize = length; FWARNING (( "RAW file length to small!\n" )); } else if(length > dataSize - fileOffset) { FWARNING (( "RAW file length to big!\n" )); } } if(needConversion) { dataBuffer = new char [ dataSize ]; } else { dataBuffer = reinterpret_cast<char *>(image->editData()); } if(fileOffset != 0) inVol->ignore (fileOffset); inVol->read ( dataBuffer, fileDataSize ); #ifdef OSG_WITH_ZLIB if(unzipper != NULL) delete unzipper; #endif } else { FWARNING (( "Can not open %s image data\n", objectFileName.c_str() )); } } else { FWARNING (( "Invalid/Missing DAT Format\n" )); } } else { FWARNING (( "Invalid/Missing DAT Resolution\n" )); } } else { FWARNING (( "Invalid/Missing DAT ObjectFileName\n" )); } // check/reformat vol data if (dataSize && dataBuffer) { // check host endian type UInt16 word = 0x0001; UInt8 *byte = reinterpret_cast<UInt8 *>(&word); bool host_big_endian = byte[0] ? false : true; if(big_endian != host_big_endian) image->swapDataEndian(); if (needConversion) { FLOG (("DAT-Data convert not impl. yet !\n")); { switch (formatType) { case Image::OSG_UINT8_IMAGEDATA: break; case Image::OSG_UINT16_IMAGEDATA: break; case Image::OSG_UINT32_IMAGEDATA: break; case Image::OSG_FLOAT32_IMAGEDATA: break; default: ; } } } else { retCode = true; } } /* TODO std::ifstream in(fileName); Head head; void *headData = (void*)(&head); unsigned dataSize, headSize = sizeof(Head); if ( in && in.read(static_cast<char *>(headData), headSize) && head.netToHost() && image.set ( Image::PixelFormat(head.pixelFormat), head.width, head.height, head.depth, head.mipmapCount, head.frameCount, float(head.frameDelay) / 1000.0) && (dataSize = image.getSize()) && in.read((char *)(image.getData()), dataSize )) retCode = true; else retCode = false; */ return retCode; }