void CIrrMeshFileLoader::readMeshBuffer(io::IXMLReader* reader, int vertexCount, SMeshBufferLightMap* sbuffer) { core::stringc data = reader->getNodeData(); const c8* p = &data[0]; if (sbuffer) { video::S3DVertex2TCoords vtx; for (int i=0; i<vertexCount && *p; ++i) { // position findNextNoneWhiteSpace(&p); vtx.Pos.X = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.Pos.Y = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.Pos.Z = readFloat(&p); // normal findNextNoneWhiteSpace(&p); vtx.Normal.X = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.Normal.Y = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.Normal.Z = readFloat(&p); // color findNextNoneWhiteSpace(&p); sscanf(p, "%08x", &vtx.Color.color); skipCurrentNoneWhiteSpace(&p); // tcoord1 findNextNoneWhiteSpace(&p); vtx.TCoords.X = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.TCoords.Y = readFloat(&p); // tcoord2 findNextNoneWhiteSpace(&p); vtx.TCoords2.X = readFloat(&p); findNextNoneWhiteSpace(&p); vtx.TCoords2.Y = readFloat(&p); sbuffer->Vertices.push_back(vtx); } } }
PathSegmentData SVGPathByteStreamSource::parseSegment() { ASSERT(hasMoreData()); PathSegmentData segment; segment.command = static_cast<SVGPathSegType>(readSVGSegmentType()); switch (segment.command) { case PathSegCurveToCubicRel: case PathSegCurveToCubicAbs: segment.point1 = readFloatPoint(); /* fall through */ case PathSegCurveToCubicSmoothRel: case PathSegCurveToCubicSmoothAbs: segment.point2 = readFloatPoint(); /* fall through */ case PathSegMoveToRel: case PathSegMoveToAbs: case PathSegLineToRel: case PathSegLineToAbs: case PathSegCurveToQuadraticSmoothRel: case PathSegCurveToQuadraticSmoothAbs: segment.targetPoint = readFloatPoint(); break; case PathSegLineToHorizontalRel: case PathSegLineToHorizontalAbs: segment.targetPoint.setX(readFloat()); break; case PathSegLineToVerticalRel: case PathSegLineToVerticalAbs: segment.targetPoint.setY(readFloat()); break; case PathSegClosePath: break; case PathSegCurveToQuadraticRel: case PathSegCurveToQuadraticAbs: segment.point1 = readFloatPoint(); segment.targetPoint = readFloatPoint(); break; case PathSegArcRel: case PathSegArcAbs: { segment.arcRadii() = readFloatPoint(); segment.setArcAngle(readFloat()); segment.arcLarge = readFlag(); segment.arcSweep = readFlag(); segment.targetPoint = readFloatPoint(); break; } default: ASSERT_NOT_REACHED(); } return segment; }
/** ------------------------------------------------------------------------ ** * \internal * * \brief Get a Translate Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformTranslate (decodeISF_t * pDecISF) { int err = OK; transform_t * pTransform; /** * This tag consists of 2 values describing a translate transform matrix.\n * Those two values are coded in the stream as floats (IEEE 754)\n * We have in order: * - dx * - dy * * The transform matrix is :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} 0 & 0 & \mbox{dx} \\ 0 & 0 & \mbox{dy} \\ 0 & 0 & 1\\ \end{array} \right) * \f] * * In fact the transform matrix shouldn't be like that cause that * transformation don't translate.\n * Anyway, it seems to work this way with the .Net 3.0 framework ... * The transform matrix should be :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} \mbox{1} & 0 & \mbox{dx} \\ 0 & \mbox{1} & \mbox{dy} \\ 0 & 0 & 1\\ \end{array} \right) * \f] */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } err = readFloat (pDecISF, &pTransform->m13); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m23); if (err != OK) return err; LOG(stdout,"(TRANSFORM_TRANSLATE) m13 = %f\n", pTransform->m13); LOG(stdout,"(TRANSFORM_TRANSLATE) m23 = %f\n", pTransform->m23); /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); return err; }
void readHotstartFile(void) // // Input: none // Output: none // Purpose: reads initial state of all nodes and links from hotstart file. // { int i, j; long pos, size; float x; // --- check that file has correct size pos = ftell(Fhotstart1.file); fseek(Fhotstart1.file, 0L, SEEK_END); size = ( ftell(Fhotstart1.file) - pos ) / sizeof(float); if ( size < Nobjects[NODE] * (2 + 2*Nobjects[POLLUT]) + Nobjects[LINK] * (3 + Nobjects[POLLUT]) ) { report_writeErrorMsg(ERR_HOTSTART_FILE_READ, ""); return; } fseek(Fhotstart1.file, pos, SEEK_SET); // --- read node states for (i = 0; i < Nobjects[NODE]; i++) { if ( !readFloat(&x) ) return; Node[i].newDepth = x; if ( !readFloat(&x) ) return; Node[i].newLatFlow = x; for (j = 0; j < Nobjects[POLLUT]; j++) { if ( !readFloat(&x) ) return; Node[i].newQual[j] = x; } // --- read in zero here for back compatibility for (j = 0; j < Nobjects[POLLUT]; j++) { if ( !readFloat(&x) ) return; } } // --- read link states for (i = 0; i < Nobjects[LINK]; i++) { if ( !readFloat(&x) ) return; Link[i].newFlow = x; if ( !readFloat(&x) ) return; Link[i].newDepth = x; if ( !readFloat(&x) ) return; Link[i].setting = x; for (j = 0; j < Nobjects[POLLUT]; j++) { if ( !readFloat(&x) ) return; Link[i].newQual[j] = x; } } }
void Noise::parse(vector<string> args) { assert(args.size() < 3, "-noise takes zero, one, or two arguments\n"); float maxVal = 1; float minVal = 0; if (args.size() == 1) { maxVal = readFloat(args[0]); } else if (args.size() == 2) { minVal = readFloat(args[0]); maxVal = readFloat(args[1]); } apply(stack(0), minVal, maxVal); }
void Quantize::parse(vector<string> args) { assert(args.size() <= 1, "-quantize takes zero or one arguments\n"); if (args.size()) apply(stack(0), readFloat(args[0])); else apply(stack(0), 1); }
float RemotePluginClient::getParameterDefault(int p) { writeOpcode(m_controlRequestFd, RemotePluginGetParameterDefault); writeInt(m_controlRequestFd, p); return readFloat(m_controlResponseFd); }
float RemotePluginClient::getVersion() { //!!! client code needs to be testing this writeOpcode(m_controlRequestFd, RemotePluginGetVersion); return readFloat(m_controlResponseFd); }
WalkingEngineKick::Value* WalkingEngineKick::readValue(char*& buf) { while(*buf == ' ' || *buf == '\t') ++buf; switch(*buf) { case '(': { ++buf; Value* result = readPlusFormula(buf); while(*buf == ' ' || *buf == '\t') ++buf; if(*buf != ')') throw ParseException("expected ')'"); ++buf; return result; } case '$': { ++buf; unsigned int i = readUInt(buf); return new ParameterValue(i, *this); } default: { float f = readFloat(buf); return new ConstantValue(f, *this); } } }
bool BranchState::readFloat( Token::Argument& argument ) { assert( argument.type() == Token::Argument::FLOAT_REGISTER ); if( argument.content() == Token::Argument::REGISTER ) { return readFloat( argument.regNumber(), argument.fields() ); } else if( argument.content() == Token::Argument::ALIAS ) { std::map< std::string, State >::iterator i = m_floats.find( argument.alias() ); // has this alias been written already? if( i == m_floats.end() ) return false; // make sure no uninitialized portion of the alias is read if( argument.fields() & (~(i->second.fields())) ) return false; // update dependency information updateDependency( argument, i->second, Alias::FLOAT, i->first, true ); } else return false; return true; }
bool CCBReader::readSequences() { auto& sequences = _animationManager->getSequences(); int numSeqs = readInt(false); for (int i = 0; i < numSeqs; i++) { CCBSequence *seq = new (std::nothrow) CCBSequence(); seq->autorelease(); seq->setDuration(readFloat()); seq->setName(readCachedString().c_str()); seq->setSequenceId(readInt(false)); seq->setChainedSequenceId(readInt(true)); if(!readCallbackKeyframesForSeq(seq)) return false; if(!readSoundKeyframesForSeq(seq)) return false; sequences.pushBack(seq); } _animationManager->setAutoPlaySequenceId(readInt(true)); return true; }
double TokenStream::readRational() { Token t; double val=readFloat(); if (!isEOF()) { nextToken(t); if (t.type == TT_SYMBOL && t.sval[0] == '/') { double div=readFloat(); val /= div; } else { pushBack(); } } return val; }
static TACommandVerdict acoshf_cmd(TAThread thread,TAInputStream stream) { float x, res; // Prepare x = readFloat(&stream); errno = 0; START_TARGET_OPERATION(thread); // Execute res = acoshf(x); END_TARGET_OPERATION(thread); // Response writeFloat(thread, res); writeInt(thread, errno); sendResponse(thread); return taDefaultVerdict; }
// Leeremos, dentro de la etiqueta strEtiqueta, nNumF floats, que // almacenaremos en el array de floats fltArray. Al llamar a este metodo // debemos garantizar que fltArray puede almacenar nNumF floats. bool Parser::readBloqueFloats(const std::string &strEtiqueta, const int nNumF, float *fltArray) { std::string strBufferEtq, strCierre("/"); char cSep; if(!ignorarChars()) return false; if(!readToken(strBufferEtq)) return false; if(strEtiqueta != strBufferEtq) return false; for(int i = 0; i < nNumF; i++) { if(i == nNumF - 1) // Ultimo float a leer cSep = '<'; else cSep = ','; if(!readFloat(fltArray[i], cSep)) return false; } strCierre += strBufferEtq; strBufferEtq.clear(); if(!readToken(strBufferEtq)) return false; if(strCierre != strBufferEtq) return false; return true; }
void MD5Model::readFrameEl(std::ifstream &fin, Anim &anim) { // numAnimatedComponents has to have been set before frame element if (0 == anim.numAnimatedComponents) throw Exception("MD5Model::readFrameEl(): numAnimatedComponents must be set before 'frame' block"); // read frame index int frameIndex = readInt(fin); if (frameIndex < 0 || frameIndex >= anim.numFrames) throw Exception("MD5Model::readFrameEl(): invalid frame index"); // get reference to frame and set number of animated components Frame &frame = anim.frames[frameIndex]; frame.animatedComponents.resize(anim.numAnimatedComponents); TOKEN t = getNextToken(fin); // expect an opening brace { to begin block if (t != TOKEN_LBRACE) throw Exception("MD5Model::readFrameEl(): expected { to follow frame index"); for (int i = 0; i < anim.numAnimatedComponents; i++) frame.animatedComponents[i] = readFloat(fin); // 刚好读取frame中的位置数加上方位数总flaot数 t = getNextToken(fin); // expect a closing brace } to end block if (t != TOKEN_RBRACE) throw Exception("MD5Model::readFrameEl(): expected }"); }
bool GTM::readTrackPoints( double& latitude, double& longitude, GIntBig& datetime, unsigned char& start, float& altitude) { /* Point to the actual trackpoint offset */ if ( VSIFSeekL(pGTMFile, actualTrackpointOffset, SEEK_SET) != 0) return false; /* Read latitude */ latitude = readDouble(pGTMFile); /* Read longitude */ longitude = readDouble(pGTMFile); /* Read trackpoint date */ datetime = readInt(pGTMFile); if (datetime != 0) datetime += GTM_EPOCH; /* Read start flag */ if ( !readFile( &start, 1, 1 ) ) return false; /* Read altitude */ altitude = readFloat(pGTMFile); ++trackpointFetched; if (trackpointFetched < ntcks) { actualTrackpointOffset += 8 + 8 + 4 + 1 + 4; } return true; }
Material* SceneParser::parsePhongMaterial() { char token[MAX_PARSER_TOKEN_LENGTH]; Vec3f diffuseColor(1, 1, 1); Vec3f specularColor(0, 0, 0); float exponent = 1; getToken(token); assert(!strcmp(token, "{")); while (1) { getToken(token); if (!strcmp(token, "diffuseColor")) { diffuseColor = readVec3f(); } else if (!strcmp(token, "specularColor")) { specularColor = readVec3f(); } else if (!strcmp(token, "exponent")) { exponent = readFloat(); } else { assert(!strcmp(token, "}")); break; } } Material *answer = new PhongMaterial(diffuseColor, specularColor, exponent); return answer; }
static Literal readLiteral(FILE *f) { int tag = readTag(f); switch (tag) { case LIT_STR: { LiteralStr lit = (LiteralStr) malloc(sizeof(struct _LiteralStr)); lit->_.tag = tag; lit->val = readString(f); return ((Literal) lit); } case LIT_INT: { LiteralInt lit = (LiteralInt) malloc(sizeof(struct _LiteralInt)); lit->_.tag = tag; lit->val = readInt(f); return ((Literal) lit); } case LIT_FLOAT: { LiteralFloat lit = (LiteralFloat) malloc(sizeof(struct _LiteralFloat)); lit->_.tag = tag; lit->val = readFloat(f); return ((Literal) lit); } default: __pgf_panic("Unknown literal tag"); } }
//! reads floats from inside of xml element until end of xml element void CIrrMeshFileLoader::readFloatsInsideElement(io::IXMLReader* reader, f32* floats, u32 count) { if (reader->isEmptyElement()) return; while(reader->read()) { // TODO: check for comments inside the element // and ignore them. if (reader->getNodeType() == io::EXN_TEXT) { // parse float data core::stringc data = reader->getNodeData(); const c8* p = &data[0]; for (u32 i=0; i<count; ++i) { findNextNoneWhiteSpace(&p); if (*p) floats[i] = readFloat(&p); else floats[i] = 0.0f; } } else if (reader->getNodeType() == io::EXN_ELEMENT_END) break; // end parsing text } }
Material * SceneParser::parseMaterial() { char token[MAX_PARSER_TOKEN_LENGTH]; char filename[MAX_PARSER_TOKEN_LENGTH]; filename[0] = 0; Vector3f diffuseColor(1,1,1), specularColor(0,0,0); float shininess=0; getToken(token); assert(!strcmp(token, "{")); while (true) { getToken(token); if (strcmp(token, "diffuseColor")==0) { diffuseColor = readVector3f(); } else if (strcmp(token, "specularColor")==0) { specularColor = readVector3f(); } else if (strcmp(token, "shininess")==0) { shininess = readFloat(); } else if (strcmp(token, "texture")==0) { getToken(filename); } else { assert(!strcmp(token, "}")); break; } } Material *answer = new Material(diffuseColor, specularColor, shininess); if(filename[0] !=0){ answer->loadTexture(filename); } return answer; }
Material* SceneParser::parseMaterial() { char token[MAX_PARSER_TOKEN_LENGTH]; char filename[MAX_PARSER_TOKEN_LENGTH]; filename[0] = 0; Vector3f diffuseColor(1,1,1), specularColor(0,0,0); float shininess=0; float refractionIndex =0; getToken(token); assert (!strcmp(token, "{")); Noise *noise =0; while (1) { getToken(token); if (strcmp(token, "diffuseColor")==0) { diffuseColor = readVector3f(); } else if (strcmp(token, "specularColor")==0) { specularColor = readVector3f(); } else if (strcmp(token, "shininess")==0) { shininess = readFloat(); }else if(strcmp(token, "refractionIndex")==0){ refractionIndex = readFloat(); } else if (strcmp(token, "texture")==0) { getToken(filename); } ///unimplemented else if (strcmp(token, "bump")==0) { getToken(token); } else if(strcmp(token,"Noise")==0){ noise = parseNoise(); } else { assert (!strcmp(token, "}")); break; } } Material *answer = new Material(diffuseColor, specularColor, shininess,refractionIndex); if(filename[0] !=0){ answer->loadTexture(filename); } if(noise != 0){ answer->setNoise(*noise); delete noise; } return answer; }
void Histogram::parse(vector<string> args) { assert(args.size() < 4, "-histogram takes three or fewer arguments\n"); int buckets = 256; float minVal = 0.0f; float maxVal = 1.0f; if (args.size() > 0) { buckets = readInt(args[0]); } if (args.size() > 1) { minVal = readFloat(args[1]); } if (args.size() > 2) { maxVal = readFloat(args[2]); } push(apply(stack(0), buckets, minVal, maxVal)); }
void Printf::parse(vector<string> args) { assert(args.size() > 0, "-printf requires at least one argument\n"); vector<float> fargs; for (unsigned i = 1; i < args.size(); i++) { fargs.push_back(readFloat(args[args.size()-i])); } apply(stack(0), args[0], fargs); }
void Mod::parse(vector<string> args) { vector<float> fargs; for (size_t i = 0; i < args.size(); i++) { fargs.push_back(readFloat(args[i])); } apply(stack(0), fargs); }
static void readCurve(spSkeletonBinary *self, spCurveTimeline *timeline, int frameIndex) { switch (readByte(self)) { case CURVE_STEPPED: { spCurveTimeline_setStepped(timeline, frameIndex); break; } case CURVE_BEZIER: { float v1 = readFloat(self); float v2 = readFloat(self); float v3 = readFloat(self); float v4 = readFloat(self); spCurveTimeline_setCurve(timeline, frameIndex, v1, v2, v3, v4); break; } } }
void FPrintf::parse(vector<string> args) { assert(args.size() > 1, "-fprintf requires at least two arguments\n"); vector<float> fargs; for (unsigned i = 2; i < args.size(); i++) { fargs.push_back(readFloat(args[args.size()-i+1])); } apply(stack(0), args[0], args[1], fargs); }
void BoneVertex::readFromFile(FILE *fp, float scale) { char nameCurrent[512]; float posx, posy, posz; float angle; float axisx, axisy, axisz; readString(fp, nameCurrent); posx = readFloat(fp) * scale; posy = readFloat(fp) * scale; posz = readFloat(fp) * scale; angle = readFloat(fp); axisx = readFloat(fp); axisy = readFloat(fp); axisz = readFloat(fp); setName(nameCurrent); setInitialPosition(posx, posy, posz); setInitialRotation(angle, axisx, axisy, axisz); int cpt = readInt(fp); // Number of children for (int i=0; i<cpt; i++) { BoneVertex *tmp = new BoneVertex(); addChild(tmp); tmp->readFromFile(fp); } compileChildList(); }
static void readVertices(spSkeletonBinary *self, spVertexAttachment *attachment, int vertexCount) { if (!readBoolean(self)) { attachment->vertices = readFloats(self, self->scale, vertexCount << 1); attachment->verticesCount = vertexCount << 1; attachment->bones = NULL; attachment->bonesCount = 0; } else { float *weights; int *bones; int weightCount = 0, boneCount = 0; int position = self->data->position; for (int i = 0; i < vertexCount; i++) { int nn = readVarint(self, true); boneCount++; for (int ii = 0; ii < nn; ii++) { readVarint(self, true); self->data->position += sizeof(float) * 3; weightCount += 3; boneCount++; } } self->data->position = position; attachment->bones = MALLOC(int, boneCount); attachment->bonesCount = boneCount; attachment->vertices = MALLOC(float, weightCount); attachment->verticesCount = weightCount; weights = attachment->vertices; bones = attachment->bones; for (int i = 0; i < vertexCount; i++) { int nn = readVarint(self, true); *bones++ = nn; for (int ii = 0; ii < nn; ii++) { *bones++ = readVarint(self, true); *weights++ = readFloat(self) * self->scale; *weights++ = readFloat(self) * self->scale; *weights++ = readFloat(self); } } } }
/// read from file coTetin__defDensPoly::coTetin__defDensPoly(istream &str, int binary) : coTetinCommand(coTetin::DEFINE_DENSITY_POLYGON) { if (binary) { } else { char lineBuf[4096]; getLine(lineBuf, 4096, str); d_npnts = 0; d_size = 0.0; getOption(lineBuf, "npnts", d_npnts); getOption(lineBuf, "size", d_size); d_name = NULL; if (getOption(lineBuf, "name", d_name) == 0) { d_name = new char[1]; d_name[0] = '\0'; } // no points ... if (d_npnts <= 0) { d_coord = NULL; return; } // read the points the safe way... float *fPtr; fPtr = d_coord = new float[3 * d_npnts]; int i; for (i = 0; i < d_npnts; i++) { getLine(lineBuf, 4096, str); char *cPtr = lineBuf; *fPtr = readFloat(cPtr); fPtr++; *fPtr = readFloat(cPtr); fPtr++; *fPtr = readFloat(cPtr); fPtr++; } } }
int NmeaParser::nmeaReadLongitude(char *s, float &longitude) { if (strlen(s) < 4) { DEBUG_BAD_PACKETS("Invalid llongitude length, %i characters", strlen(s)); return 0; } longitude = (float(readNDigitsInt(s, 3) * 60) + readFloat(s+3)) * float(M_PI / (180 * 60)); return 1; }