void PhysicObject::savePhysProperties(FILE* f) { writeChar(isEnabledPhysics(), f); if (!isEnabledPhysics()) return; writeFloat(getMass(), f); writeVector(getAngularFactor(), f); writeVector(getLinearFactor(), f); //writeVector(getLinearVelocity(), f); writeChar(isTrigger(), f); writeChar(getCollisionShapeType(), f); writeChar(isEnableDeactivation(), f); writeFloat(getFriction(), f); writeFloat(getRestitution(), f); writeFloat(getLinearDumping(), f); writeFloat(getAngularDumping(), f); // save custom collision shape if (getCollisionShapeType() == CST_CUSTOM) { if (getCollisionShape() == NULL) Log::error("Can't save custom col. shape. (shape is NULL) id=%s", objectID.c_str()); writeChar(getCollisionShape()->getCollisionShapeType() , f); getCollisionShape()->save(f); } // save constraints writeChar(getConstrains().size(), f); for (unsigned int i = 0; i < getConstrains().size(); i++) { writeChar(getConstrains().at(i)->getType(), f); getConstrains().at(i)->save(f); } }
std::ostream& ProcFile::writeOutputPortals(std::ostream& str, ProcEntity& entity) { str << (boost::format("interAreaPortals { /* numAreas = */ %i /* numIAP = */ %i") % entity.numAreas % interAreaPortals.size()) << std::endl << std::endl; str << "/* interAreaPortal format is: numPoints positiveSideArea negativeSideArea ( point) ... */" << std::endl; for (std::size_t i = 0; i < interAreaPortals.size(); ++i) { const ProcInterAreaPortal& iap = interAreaPortals[i]; const ProcWinding& w = iap.side->winding; str << (boost::format("/* iap %i */ %i %i %i ") % i % w.size() % iap.area0 % iap.area1); str << "( "; for (std::size_t j = 0; j < w.size(); ++j) { writeFloat(str, w[j].vertex[0]); writeFloat(str, w[j].vertex[1]); writeFloat(str, w[j].vertex[2]); } str << ") "; str << std::endl; } str << "}" << std::endl<< std::endl; return str; }
void DataOutputStream::writeVec4(const osg::Vec4& v){ writeFloat(v.x()); writeFloat(v.y()); writeFloat(v.z()); writeFloat(v.w()); if (_verboseOutput) std::cout<<"read/writeVec4() ["<<v<<"]"<<std::endl; }
void DataOutputStream::writeQuat(const osg::Quat& q){ writeFloat(q.x()); writeFloat(q.y()); writeFloat(q.z()); writeFloat(q.w()); if (_verboseOutput) std::cout<<"read/writeQuat() ["<<q<<"]"<<std::endl; }
OGRGTMDataSource::~OGRGTMDataSource() { if (fpTmpTrackpoints != NULL) VSIFCloseL( fpTmpTrackpoints ); if (fpTmpTracks != NULL) VSIFCloseL( fpTmpTracks ); WriteWaypointStyles(); AppendTemporaryFiles(); if( fpOutput != NULL ) { /* Adjust header counters */ VSIFSeekL(fpOutput, NWPTS_OFFSET, SEEK_SET); writeInt(fpOutput, numWaypoints); writeInt(fpOutput, numTrackpoints); VSIFSeekL(fpOutput, NTK_OFFSET, SEEK_SET); writeInt(fpOutput, numTracks); /* Adjust header bounds */ VSIFSeekL(fpOutput, BOUNDS_OFFSET, SEEK_SET); writeFloat(fpOutput, maxlon); writeFloat(fpOutput, minlon); writeFloat(fpOutput, maxlat); writeFloat(fpOutput, minlat); VSIFCloseL( fpOutput ); } if (papoLayers != NULL) { for( int i = 0; i < nLayers; i++ ) delete papoLayers[i]; CPLFree( papoLayers ); } if (pszName != NULL) CPLFree( pszName ); if (pszTmpTracks != NULL) { VSIUnlink( pszTmpTracks ); CPLFree( pszTmpTracks ); } if (pszTmpTrackpoints != NULL) { VSIUnlink( pszTmpTrackpoints ); CPLFree( pszTmpTrackpoints ); } if (poGTMFile != NULL) delete poGTMFile; }
void DataOutputStream::writeVec3(const osg::Vec3& v){ // std::cout << "write " << _ostream->tellp() << std::endl; writeFloat(v.x()); writeFloat(v.y()); writeFloat(v.z()); if (_verboseOutput) std::cout<<"read/writeVec3() ["<<v<<"]"<<std::endl; }
void writeViewBox(const char* value, FILE* out) { float x, y, w, h; if (sscanf(value, "%f %f %f %f", &x, &y, &w, &h) != 4) { fprintf(stderr, "Unable to parse \"%s\" as a viewBox value\n", value); throw ErrBadAttribute; } writeFloat(x, out); writeFloat(y, out); writeFloat(w, out); writeFloat(h, out); }
std::ostream& ProcFile::writeShadowTriangles(std::ostream& str, const Surface& tri) { // emit this chain str << (boost::format("/* numVerts = */ %i /* noCaps = */ %i /* noFrontCaps = */ %i /* numIndexes = */ %i /* planeBits = */ %i") % tri.vertices.size() % tri.numShadowIndicesNoCaps % tri.numShadowIndicesNoFrontCaps % tri.indices.size() % tri.shadowCapPlaneBits); str << std::endl; // verts std::size_t col = 0; for (std::size_t i = 0 ; i < tri.vertices.size(); ++i) { str << "( "; writeFloat(str, tri.shadowVertices[i][0]); writeFloat(str, tri.shadowVertices[i][1]); writeFloat(str, tri.shadowVertices[i][2]); str << " )"; if (++col == 5) { col = 0; str << std::endl; } } if (col != 0) { str << std::endl; } // indexes col = 0; for (std::size_t i = 0 ; i < tri.indices.size(); ++i) { str << (boost::format("%i ") % (str, tri.indices[i])); if (++col == 18 ) { col = 0; str << std::endl; } } if (col != 0) { str << std::endl; } return str; }
std::ostream& ProcFile::writeOutputNodeRecursively(std::ostream& str, const BspTreeNodePtr& node) { if (node->planenum == PLANENUM_LEAF) { // we shouldn't get here unless the entire world // was a single leaf str << "/* node 0 */ ( 0 0 0 0 ) -1 -1" << std::endl; return str; } int child[2]; for (std::size_t i = 0; i < 2; ++i) { if (node->children[i]->planenum == PLANENUM_LEAF) { child[i] = static_cast<int>(-1 - node->children[i]->area); } else { child[i] = node->children[i]->nodeNumber; } } const Plane3& plane = planes.getPlane(node->planenum); str << (boost::format("/* node %i */ ") % node->nodeNumber); str << "( "; writeFloat(str, plane.normal()[0]); writeFloat(str, plane.normal()[1]); writeFloat(str, plane.normal()[2]); writeFloat(str, -plane.dist()); str << ") "; str << (boost::format("%i %i") % child[0] % child[1]) << std::endl; if (child[0] > 0) { writeOutputNodeRecursively(str, node->children[0]); } if (child[1] > 0) { writeOutputNodeRecursively(str, node->children[1]); } return str; }
void SE_BufferOutput::writeFloatArray(float* fa, int count) { for(int i = 0 ; i < count ; i++) { writeFloat(fa[i]); } }
void BranchState::writeFloat( Token::Argument& argument ) { assert( argument.type() == Token::Argument::FLOAT_REGISTER ); if( argument.content() == Token::Argument::REGISTER ) { writeFloat( argument.regNumber(), argument.fields() ); } else if( argument.content() == Token::Argument::ALIAS ) { std::map< std::string, State >::iterator i = m_floats.find( argument.alias() ); if( i == m_floats.end() ) { State newState; m_floats[ argument.alias() ] = newState; i = m_floats.find( argument.alias() ); // this could be retrieved directly, but I've had issues with inserting into maps and retrieving the iterator in the same operation assert( i != m_floats.end() ); } updateDependency( argument, i->second, Alias::FLOAT, i->first, ((i->second.fields() & ~argument.fields()) != 0) ); i->second.setFields( i->second.fields() | argument.fields() ); } }
void SE_BufferOutput::writeVector4f(const SE_Vector4f& v) { for(int i = 0 ; i < 4 ; i++) { writeFloat(v.d[i]); } }
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; }
void SE_BufferOutput::writeMatrix3f(const SE_Matrix3f& m) { for(int i = 0 ; i < 3 ; i++) { for(int j = 0 ; j < 3 ; j++) writeFloat(m.get(i, j)); } }
void writeFixed(const char* value, FILE* out) { float f; if (sscanf(value, "%f", &f) != 1) { fprintf(stderr, "Unable to parse \"%s\" as a floating point value\n", value); throw ErrBadAttribute; } writeFloat(f, out); }
//-------------------------------------------------------------- void DataStream::writeFloatBE(float n) { #ifdef AZURA_LITTLE_ENDIAN _s4((_4*)&n); #endif writeFloat(n); }
void RemotePluginClient::setParameter(int p, float v) { writeOpcode(&m_shmControl->ringBuffer, RemotePluginSetParameter); writeInt(&m_shmControl->ringBuffer, p); writeFloat(&m_shmControl->ringBuffer, v); commitWrite(&m_shmControl->ringBuffer); }
static TACommandVerdict __wcstof_internal_cmd(TAThread thread,TAInputStream stream) { wchar_t* st, *endptr; size_t size; float res; size = readInt(&stream); st = (wchar_t*)ta_alloc_memory(size * sizeof(wchar_t) + 1); readWCharArray(&stream, st, &size); st[size] = '\0'; START_TARGET_OPERATION(thread); errno = 0; res = __wcstof_internal(st, &endptr, 0); END_TARGET_OPERATION(thread); writeFloat(thread, res); writeInt(thread, (int)( endptr - st)); writeInt(thread, errno); ta_dealloc_memory(st); sendResponse(thread); return taDefaultVerdict; }
void BoneVertex::writeToFile(FILE *fp) { if (! childListCompiled) compileChildList(); writeString(fp, getName()); float posx, posy, posz; float angle; float axisx, axisy, axisz; posx = initialPosition.x; posy = initialPosition.y; posz = initialPosition.z; angle = initialAngle; axisx = initialAxis.x; axisy = initialAxis.y; axisz = initialAxis.z; writeFloat(fp, posx); writeFloat(fp, posy); writeFloat(fp, posz); writeFloat(fp, angle); writeFloat(fp, axisx); writeFloat(fp, axisy); writeFloat(fp, axisz); writeInt(fp, children); for (int i=0; i<children; i++) child[i]->writeToFile(fp); }
static TACommandVerdict sincosf_cmd(TAThread thread,TAInputStream stream) { float x, s, c; x = readFloat(&stream); START_TARGET_OPERATION(thread); sincosf(x, &s, &c); END_TARGET_OPERATION(thread); writeFloat(thread, s); writeFloat(thread, c); sendResponse(thread); return taDefaultVerdict; }
void EntityTemplateInterpreter::generateTestByteCode() { std::ofstream out("autoGenerated.tpl", std::ofstream::binary); writeByte(0xB0, out); writeByte(0x01, out);writeString("size", out); writeByte(0x02, out);writeString("testFloat", out); writeByte(0x03, out);writeString("testString", out); writeByte(0x04, out);writeString("I AM SUCH A STRING", out); writeByte(0x05, out);writeString("testInt", out); writeByte(0x06, out);writeString("ball.png", out); writeByte(0x07, out);writeString("fancy", out); writeByte(0xB1, out); writeVec2(glm::vec2(100,100), out); //Size writeByte(0x01, out); writeFloat(33.544f, out); //testFloat writeByte(0x02, out); writeByte(0xD5, out);writeByte(0x04, out); //testString writeByte(0x03, out); writeVec3(glm::vec3(349,43,435), out); //testInt writeByte(0x05, out); writeByte(0xB2, out); writeByte(0xC0, out); //TextureComponent writeByte(0xD5, out); writeByte(0x06, out); writeUint16(5, out); writeUint16(1, out); writeUint16(3, out); writeUint16(1, out); writeByte(0xC1, out); //ScriptComponent writeByte(0xD5, out); writeByte(0x07, out); writeByte(0xC2, out); //MoveComponent writeFloat(20.f, out); //Acc writeFloat(4.f, out); //Damping writeFloat(20.f, out); //Mass writeFloat(4.f, out); //Deacc writeByte(0xC3, out); //CollisionComponent writeUint16(1, out); //Box Count writeFloat(20.f, out); //x writeFloat(4.f, out); //y writeFloat(20.f, out); //w writeFloat(4.f, out); //h writeByte(0xD5, out); writeByte(0xA7, out); //Trigger Name }
void BaseSerializedObj::writeFloatArray(float array[], uint64_t s) { writeUInt64(s); uint64_t i = 0; while ( i!=s ) { writeFloat(array[i]); i++; } }
void DataOutputStream::writeFloatArray(const osg::FloatArray* a) { int size = a->getNumElements(); writeInt(size); for(int i =0; i<size ;i++){ writeFloat((*a)[i]); } if (_verboseOutput) std::cout<<"read/writeFloatArray() ["<<size<<"]"<<std::endl; }
// ---------------------------------------------------------------------- std::vector<char>* PolygonTopologyPacket:: serialize( void ) throw() { std::vector<char> *b = (static_cast<SpyglassPacket*>(this))->serialize(); int standardsize = b->size()-1; length_ = get_size(); b->resize(length_+1); writeChar( length_, b, 0); writeChar( polType_, b, standardsize+1 ); int size = polygon_.size(); for (int i=0; i<size; ++i) { shawn::Vec pos = polygon_.front(); writeFloat(pos.x(), b, standardsize+2+i*8); writeFloat(pos.y(), b, standardsize+6+i*8); polygon_.pop_front(); } return b; }
void storeSensorsZeroToEEPROM() { // Store accel data to EEPROM writeFloat(accelOneG, ACCEL_1G_ADR); // Accel Cal writeFloat(accelScaleFactor[XAXIS], XAXIS_ACCEL_SCALE_FACTOR_ADR); writeFloat(runTimeAccelBias[XAXIS], XAXIS_ACCEL_BIAS_ADR); writeFloat(accelScaleFactor[YAXIS], YAXIS_ACCEL_SCALE_FACTOR_ADR); writeFloat(runTimeAccelBias[YAXIS], YAXIS_ACCEL_BIAS_ADR); writeFloat(accelScaleFactor[ZAXIS], ZAXIS_ACCEL_SCALE_FACTOR_ADR); writeFloat(runTimeAccelBias[ZAXIS], ZAXIS_ACCEL_BIAS_ADR); }
void DataOutputStream::writeMatrixf(const osg::Matrixf& mat) { for(int r=0;r<4;r++) { for(int c=0;c<4;c++) { writeFloat(mat(r,c)); } } if (_verboseOutput) std::cout<<"read/writeMatrix() ["<<mat<<"]"<<std::endl; }
EDLL int AoscMessage::getBytes(byte *data, int sizemax) { int size=0; memset(data, 0, sizemax); size+=writeString(pattern, data, sizemax); format[0]=','; { Anode *n=lchild; char *f=&format[1]; while(n) { if(n->isCI(&AoscString::CI)) *(f++)='s'; else if(n->isCI(&AoscInteger::CI)) *(f++)='i'; else if(n->isCI(&AoscFloat::CI)) *(f++)='f'; else if(n->isCI(&AoscColor::CI)) *(f++)='r'; else if(n->isCI(&AoscBitmap::CI)) *(f++)='j'; n=n->prev; } *f=0; } size+=writeString(format, data+size, sizemax-size); { Anode *n=lchild; while(n) { if(n->isCI(&AoscString::CI)) size+=writeString(((AoscString *)n)->value, data+size, sizemax-size); else if(n->isCI(&AoscInteger::CI)) size+=writeInt(((AoscInteger *)n)->value, data+size, sizemax-size); else if(n->isCI(&AoscFloat::CI)) size+=writeFloat(((AoscFloat *)n)->value, data+size, sizemax-size); else if(n->isCI(&AoscColor::CI)) size+=writeInt(((AoscColor *)n)->value, data+size, sizemax-size); else if(n->isCI(&AoscBitmap::CI)) size+=writeBitmap(((AoscBitmap *)n)->value, data+size, sizemax-size); n=n->prev; } } return size; }
static TACommandVerdict tanf_cmd(TAThread thread,TAInputStream stream) { float x, res; x = readFloat(&stream); START_TARGET_OPERATION(thread); errno = 0; res = tanf(x); END_TARGET_OPERATION(thread); writeInt(thread, errno); writeFloat(thread, res); sendResponse(thread); return taDefaultVerdict; }
static TACommandVerdict lgammaf_r_cmd(TAThread thread,TAInputStream stream) { float x, res; int signp; x = readFloat(&stream); START_TARGET_OPERATION(thread); errno = 0; res = lgammaf_r(x, &signp); END_TARGET_OPERATION(thread); writeInt(thread, errno); writeFloat(thread, res); writeInt(thread, signp); sendResponse(thread); return taDefaultVerdict; }
int main(void) { // create memory system with 256 words and a direct-mapped cache // with 8 sets and a block size of 4 words. void *a = initializeMemorySystem(SIZE, 1, 4, 8, 1, 1); if (a == NULL) { fprintf(stderr, "initializeMemorySystem failed!\n"); exit(-1); } int i; // initialize the array for (i = 0; i < SIZE; i++) { writeFloat(a, 0, i, ((float) i) + .5); } // now sum it float sum = 0.0; float sum2 = 0.0; for (i = 0; i < SIZE; i++) { float tmp = readFloat(a, 0, i); //printf("%d %f\n", i, tmp); sum += tmp; sum2 += (((float) i) + .5); } printf("sum is %f (should be %f)\n", sum, sum2); // print stats printf("\n"); printStatistics(a); printf("\n"); return 0; }