void DPO_TableConcat::WriteToFile()
{
// ver 0
const int objMajVer = 2; // added skipFirstColumn
// const int objMajVer = 1; // added concatRows
// const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
WriteBool(concatRows); // v1
WriteBool(skipFirstColumn); // v2
WriteLine();
int nSel = 0;
for (int i = 0; i < maxInputTable; i++)
if (tablesToConcat[i].doTable)
nSel++;
WriteInt(nSel);
WriteLine();
for (int i = 0; i < maxInputTable; i++)
if (tablesToConcat[i].doTable)
{
WriteFuncObjRef(tablesToConcat[i].tableObjRef);
}
WriteLine();
}
void DataCaptureStaticSupport::WriteDataCapture(DataCaptureSpecGlob& outDC)
{
WriteText(outDC.dataDesig);
WriteBool(outDC.makeDefaultDataDesig);
WriteInt(outDC.captureType);
WriteInt(outDC.pressureCapType);
WriteInt(outDC.flowCapType);
WriteInt(outDC.productionCapType);
WriteInt(outDC.testZoneCapType);
WriteUnitReal(outDC.radiusData);
WriteBool(outDC.zvalueIsRatio); // added v3
WriteUnitReal(outDC.actualZ); // added v3
WriteDouble(outDC.normalizedZ); // added v3
WriteUnitReal(outDC.obsXLocation); // addec v4
WriteUnitReal(outDC.obsYLocation); // addec v4
WriteLine(); // added v5
WriteText(outDC.wellboreZoneID); // added v5
WriteUnitIndex(outDC.outputUnits);
WriteGlobalFunc(outDC.outputFO);
WriteLine();
WriteInt(outDC.superData.ValidSize());
WriteLine();
for (int i = 0; i < outDC.superData.Size(); i++)
if (outDC.superData.IsValid(i))
WriteSuperComponent(outDC.superData.GetRef(i));
}
/*
================
idSaveGame::WriteRenderEntity
================
*/
void idSaveGame::WriteRenderEntity( const renderEntity_t &renderEntity ) {
int i;
WriteModel( renderEntity.hModel );
WriteInt( renderEntity.entityNum );
WriteInt( renderEntity.bodyId );
WriteBounds( renderEntity.bounds );
// callback is set by class's Restore function
WriteInt( renderEntity.suppressSurfaceInViewID );
WriteInt( renderEntity.suppressShadowInViewID );
WriteInt( renderEntity.suppressShadowInLightID );
WriteInt( renderEntity.allowSurfaceInViewID );
WriteVec3( renderEntity.origin );
WriteMat3( renderEntity.axis );
WriteMaterial( renderEntity.customShader );
WriteMaterial( renderEntity.referenceShader );
WriteSkin( renderEntity.customSkin );
if( renderEntity.referenceSound != NULL ) {
WriteInt( renderEntity.referenceSound->Index() );
} else {
WriteInt( 0 );
}
for( i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ ) {
WriteFloat( renderEntity.shaderParms[ i ] );
}
for( i = 0; i < MAX_RENDERENTITY_GUI; i++ ) {
WriteUserInterface( renderEntity.gui[ i ], renderEntity.gui[ i ] ? renderEntity.gui[ i ]->IsUniqued() : false );
}
WriteFloat( renderEntity.modelDepthHack );
WriteBool( renderEntity.noSelfShadow );
WriteBool( renderEntity.noShadow );
WriteBool( renderEntity.noDynamicInteractions );
WriteBool( renderEntity.weaponDepthHack );
WriteInt( renderEntity.forceUpdate );
}
void DPO_BasicSequenceFit::WriteToFile()
{
const int objMajVer = 2; // added field & sim reduce
// const int objMajVer = 1; // added coverage test & multiplier
// const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
// base class
WriteFuncObjRef(simResultsObjRef);
WriteInt(int(fitCalcType));
WriteDouble(fitSigma);
WriteBool(fitIsNormed);
WriteDouble(minCoverage); // added v1
WriteDouble(coveragePenalty); // added v1
WriteBool(removeFieldDuplicates); // v2
WriteBool(removeSimDuplicates);
WriteDouble(duplicateEps);
WriteLine();
// derived current
WriteFuncObjRef(xyInputObjRef);
WriteTimeLimits(timeLimits);
WriteInterpPoints(interpPoints);
}
/*
================
idSaveGame::WriteRenderLight
================
*/
void idSaveGame::WriteRenderLight( const renderLight_t &renderLight ) {
int i;
WriteMat3( renderLight.axis );
WriteVec3( renderLight.origin );
WriteInt( renderLight.suppressLightInViewID );
WriteInt( renderLight.allowLightInViewID );
WriteBool( renderLight.noShadows );
WriteBool( renderLight.noSpecular );
WriteBool( renderLight.pointLight );
WriteBool( renderLight.parallel );
WriteVec3( renderLight.lightRadius );
WriteVec3( renderLight.lightCenter );
WriteVec3( renderLight.target );
WriteVec3( renderLight.right );
WriteVec3( renderLight.up );
WriteVec3( renderLight.start );
WriteVec3( renderLight.end );
// only idLight has a prelightModel and it's always based on the entityname, so we'll restore it there
// WriteModel( renderLight.prelightModel );
WriteInt( renderLight.lightId );
WriteMaterial( renderLight.shader );
for( i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ ) {
WriteFloat( renderLight.shaderParms[ i ] );
}
if( renderLight.referenceSound != NULL ) {
WriteInt( renderLight.referenceSound->Index() );
} else {
WriteInt( 0 );
}
}
void LayerStaticSupport::WriteToFile()
{
WriteGroupHeader(groupHeader, majorVersion, minorVersion);
// control
WriteBool(enterLayerDepths);
WriteUnitReal(bottomLayerDepth);
WriteUnitReal(bottomLayerElevation);
WriteBool(useCommonHistory);
WriteUnitIndex(wellboreZoneDeltaVolumeUnits);
WriteUnitIndex(wellboreZoneTZCompUnits);
WriteLine();
WriteInt(geologyLayers.Size());
WriteInt(wellBoreZones.Size());
WriteLine();
SetRealConvFormat(SC_SciFormat(12));
for (int i = 0; i < geologyLayers.Size(); i++)
WriteGeoLayer(geologyLayers[i]);
for (int i = 0; i < wellBoreZones.Size(); i++)
WriteWellBoreZone(wellBoreZones[i]);
}
void SampleStaticSupport::WriteToFile()
{
WriteGroupHeader(groupHeader, majorVersion, minorVersion);
// global objects
WriteGlobalFunc(sampResultsFO);
WriteGlobalFunc(uncertInput); //added v3
WriteGlobalFunc(uncertResultsFO); //added v3
// static control variables basic
WriteInt(int(uncertType)); //added v3
WriteBool(samplingIsLHS);
WriteBool(specifyCorrelations);
WriteBool(forceCorrelationsToZero);
WriteInt(numberOfTrials);
WriteInt(randSeed);
WriteInt(singleRunRealization);
WriteBool(calcDerivSpan); //added v3
WriteDouble(derivSpan); //added v3
WriteLine();
// selected metrics - added v3
for (int i = 0; i < UncertInput::maxMetricSel; i++)
{
WriteBool(uncertInput.inputMetrics[i].uncertOnMetric);
WriteFuncObjRef(uncertInput.inputMetrics[i].metricObject);
}
WriteLine();
}
void WriteContourSpec(const PSC_ContourSpec& contourSpec)
{
const int scalarVer = 2; // added mitreLine
// const int scalarVer = 1; // added master override
// const int scalarVer = 0;
WriteInt(scalarVer);
WriteLine();
WriteFuncObjRef(contourSpec.dataObjRef);
WriteFuncObjRef(contourSpec.specMasterObjRef);
WriteBool(contourSpec.specIsMaster);
WriteBool(contourSpec.calcIncVal);
WriteBool(contourSpec.doLogInc);
SetRealConvFormat(SC_RealFormat(ncf_Scientific, 8));
WriteDouble(contourSpec.startVal);
WriteDouble(contourSpec.endVal);
WriteDouble(contourSpec.incVal);
WriteInt(contourSpec.nIncs);
WriteInt(contourSpec.contourLineSpec.linePen);
WriteInt(contourSpec.contourLineSpec.lineThickness);
WriteInt(contourSpec.contourLineSpec.lineType);
WriteBool(contourSpec.contourLineSpec.mitreLines); // v2
WriteBool(contourSpec.overrideMasterLineSpec);
WriteLegendOverride(contourSpec.legendGC);
}
void WriteColorLegendSpec(const PSC_ColorLegendSpec& legendSpec)
{
const int specVer = 0;
WriteInt(specVer);
WriteLine();
WriteFuncObjRef(legendSpec.colorLegendObjRef);
SetRealConvFormat(SC_RealFormat(ncf_Decimal, 3));
WriteDouble(legendSpec.barLength );
WriteDouble(legendSpec.barAspect );
WriteLine();
WriteInt(int(legendSpec.orientation));
WriteBool(legendSpec.ticsAtIncs );
WriteBool(legendSpec.dataTypeLabel );
WriteLine();
WriteBool(legendSpec.dataLabelAboveLeft);
WriteBool(legendSpec.incLabelAboveLeft);
WriteBool(legendSpec.overrideLabel);
WriteLine();
WriteText(legendSpec.newLabel);
}
void PPO_GridFishnet::WriteToFile()
{
// ver 0
const int objMajVer = 1; // added missing plotAsTubes
// const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
PPO_Base::WriteToFile();
WriteFuncObjRef(penSetObjRef);
WriteFuncObjRef(gridDataObjRef);
WriteLine();
WriteBool(plotAsTubes);
WriteInt(gridPen);
WriteInt(gridLineThk);
WriteInt(gridLineType);
WriteLine();
WriteInt(xplotModulus);
WriteBool(plotLastX);
WriteInt(yplotModulus);
WriteBool(plotLastY);
WriteLine();
WriteTubeExtrusionSpec(tubeData);
WriteLegendOverride(legendOverride);
Write3DCoordMap(coordMap);
}
void MenuObjC:: WriteObjectHeader(int majVer, int minVer) const
{
WriteText(allocName);
WriteInt(majVer);
WriteInt(minVer);
WriteLine();
// address for object matching
if ( objFunction)
{
WriteFuncObj(objFunction);
WriteText(objFunction->GetID());
WriteBool(objFunction->objIDisDefault);
WriteLine();
}
else
{
WriteText(objectID);
}
WriteBool(objDeleteable);
WriteBool(objCopyable);
WriteBool(objSelected);
WriteLine();
// reset real format
SetRealConvFormat(SC_RealFormat());
}
/*
===================
idSaveGame::WriteClipModel
===================
*/
void idSaveGame::WriteClipModel( const idClipModel *clipModel ) {
if ( clipModel != NULL ) {
WriteBool( true );
clipModel->Save( this );
} else {
WriteBool( false );
}
}
void WritePolygonExtrusionSpec(const PSC_PolygonExtrusionSpec& extrusionSpec)
{
static const int extrudeVer = 0;
WriteInt(extrudeVer);
WriteBool(extrusionSpec.capEnds);
WriteBool(extrusionSpec.adjustForScaling);
WriteLine();
}
void WriteArrowSpec(const PSC_ArrowSpec& arrowSpec)
{
const int specVer = 0;
WriteInt(specVer);
WriteLine();
WriteBool(arrowSpec.plotHeads);
WriteBool(arrowSpec.fillHeads);
WriteInt(arrowSpec.headSize);
WriteInt(arrowSpec.lineThk);
WriteLine();
}
bool OutStream::WriteAggregate (const Transform& datum)
{
return WriteAggregate(datum.mHMatrix)
&& WriteAggregate(datum.mInvHMatrix)
&& WriteAggregate(datum.mMatrix)
&& WriteAggregate(datum.mTranslate)
&& WriteAggregate(datum.mScale)
&& WriteBool(datum.mIsIdentity)
&& WriteBool(datum.mIsRSMatrix)
&& WriteBool(datum.mIsUniformScale)
&& WriteBool(datum.mInverseNeedsUpdate);
}
void Write3DSeriesSpec(const PSC_3DSeriesSpec& seriesSpec)
{
WriteSeriesSpec(seriesSpec);
WriteEdgeSpec(seriesSpec);
WriteTubeExtrusionSpec(seriesSpec);
// WriteInt(int(seriesSpec.plotLineType)); // removed v1
WriteBool(seriesSpec.plotLineAsTube); // added v1
WriteBool(seriesSpec.plotSymEdges);
WriteBool(seriesSpec.plotTubeEdges);
WriteLine();
}
void IO_ProfileSimResults::WriteOneCase(const ProfileSimCaseResults& caseRes,
int& nextRec)
{
BufferReset(nextRec);
WriteString(caseRes.caseID, ProfileSimCaseResults::caseIDLen);
WriteDouble(caseRes.staticPressure);
WriteBool(caseRes.caseDataIsExtended);
WriteInt(caseRes.caseValues.Size());
for (int i = 0; i < caseRes.caseValues.Size(); i++)
WriteDouble(caseRes.caseValues[i]);
if (!caseRes.caseDataIsExtended)
{
const DC_GridData& currGrid = caseRes.caseData;
WriteString(currGrid.gridID, DC_GridData::gridIDLen);
WriteString(currGrid.xData.dataID, DC_DataCoord::dataIDLen);
WriteString(currGrid.yData.dataID, DC_DataCoord::dataIDLen);
WriteBool(currGrid.xData.dataIsLog);
WriteBool(currGrid.yData.dataIsLog);
WriteInt(currGrid.xData.Size());
WriteInt(currGrid.yData.Size());
WriteDoubleArray(currGrid.xData);
WriteDoubleArray(currGrid.yData);
for (int i = 0; i < currGrid.Size(); i++)
WriteDouble(currGrid[i]);
}
else
{
const ExtendedProfile& currPro = caseRes.extendedCaseData;
WriteInt(currPro.ntotalVert);
WriteInt(currPro.nradial);
WriteInt(currPro.nconstantVert);
WriteInt(currPro.nvariableVert);
// WriteDouble(currPro.constantVertThick); // v1
WriteDoubleArray(currPro.constantVertZPos);
WriteDoubleArray(currPro.nodeRadii);
WriteInt(currPro.Size());
for (int i = 0; i < currPro.Size(); i++)
{
const ExtendedProfileTimeData& currSing = currPro[i];
WriteDouble(currSing.profileTime);
if (currPro.nvariableVert > 0)
WriteDoubleArray(currSing.waterTablePos);
WriteDoubleMatrix(currSing.nodalPressures);
}
}
FlushBuffer(nextRec);
}
void LayerStaticSupport::WriteGeoLayer(const GeologyLayer& outLayer)
{
WriteText(outLayer.intervalID);
WriteUnitReal(outLayer.topDepth);
WriteUnitReal(outLayer.topElevation);
WriteInt(outLayer.nintervalNodes);
WriteLine();
WriteBool(outLayer.layerHasSkin);
WriteBool(outLayer.layerIsIsotropic);
WriteInt(outLayer.parIndex);
WriteLine();
}
void WriteTubeExtrusionSpec(const PSC_TubeExtrusionSpec& extrusionSpec)
{
static const int extrudeVer = 0;
WriteInt(extrudeVer);
WriteInt(extrusionSpec.nextrusionPoints);
WriteBool(extrusionSpec.usePixelSizing);
WriteInt(extrusionSpec.extrusionPixelSize);
WriteDouble(extrusionSpec.extrusionRealSize, SC_RealFormat(ncf_Scientific, 5));
WriteBool(extrusionSpec.capEnds);
WriteBool(extrusionSpec.adjustForScaling);
WriteLine();
}
void DPO_BasicResidual::WriteToFile()
{
const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
WriteFuncObjRef(residInputObjRef);
WriteInt(int(sortingSpec));
WriteBool(standardize);
WriteBool(xoutputIsIndex);
WriteLine();
}
void DPO_CompositeFit::WriteToFile()
{
const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
for (int i = 0; i < maxFitData; i++)
{
WriteFuncObjRef(fitData[i].inputFitObjRef);
WriteBool(fitData[i].useFit);
WriteDouble(fitData[i].fitScaling);
WriteBool(fitData[i].logFit);
WriteLine();
}
}
void WriteDateFormat(const DC_DateFormat& df)
{
const int specVer = 0;
WriteInt(specVer);
WriteLine();
WriteInt(int(df.dateOrder));
WriteInt(int(df.monthFormat));
WriteBool(df.dayHasLeadingZero);
WriteBool(df.yearIsFull);
WriteLine();
WriteTextWithTrailingBlanks(df.delim1);
WriteTextWithTrailingBlanks(df.delim2);
WriteLine();
}
void SkinnedMeshNode::SerializeOut( std::ofstream& stream )
{
unsigned short ver = SKINNEDMESH_LASTEST;
unsigned char count =0 ;
//scene
stream.write((char*)&m_type,sizeof(m_type));
stream.write((char*)&ver,sizeof(ver));
WriteString(stream,m_strNodeName);
WriteString(stream,m_strParentName);
WriteMatrix(stream,m_nodeTM);
stream.write((char*)&m_materialRefIndex,sizeof(m_materialRefIndex));
stream.write((char*)&m_materialSubIndex,sizeof(m_materialSubIndex));
stream.write((char*)&m_primitiveCount,sizeof(m_primitiveCount));
stream.write((char*)&m_startIndex,sizeof(m_startIndex));
WriteBool(stream,m_bInstancingEnable);
// mesh
SerializeOutMesh(stream);
// child
count = m_vecChildNode.size();
stream.write((char*)&count,sizeof(count));
auto it_child = m_vecChildNode.begin();
for ( ;it_child!=m_vecChildNode.end();++it_child )
{
(*it_child)->SerializeOut(stream);
}
}
void DPO_TableColAccumulate::WriteToFile()
{
const int objMajVer = 1; //added option to null zero accumulation values
//const int objMajVer = 0;
const int objMinVer = 0;
WriteObjectHeader(objMajVer, objMinVer);
WriteFuncObjRef(inputTableObjRef);
WriteBool(skipXColumn);
WriteInt(xcolumnIndex);
WriteBool(nullZeroAccValues);
WriteLine();
}
void WriteIndexMSSpec(const DSC_IndexMSSpec& outSpec)
{
WriteBool(outSpec.indexIsMaster);
WriteFuncObjRef(outSpec.indexMasterObjRef);
WriteInt(outSpec.enteredIndexValue);
WriteLine();
// new index spec stuff
if (outSpec.MultipleOK())
{
if (outSpec.SingleOK())
WriteBool(outSpec.enteredIndexIsSingle);
WriteIntArray(outSpec.enteredIndexArray);
}
}
/*
===================
idRestoreGame::WriteTraceModel
===================
*/
void idSaveGame::WriteTraceModel( const idTraceModel &trace ) {
int j, k;
WriteInt( (int&)trace.type );
WriteInt( trace.numVerts );
for ( j = 0; j < MAX_TRACEMODEL_VERTS; j++ ) {
WriteVec3( trace.verts[j] );
}
WriteInt( trace.numEdges );
for ( j = 0; j < (MAX_TRACEMODEL_EDGES+1); j++ ) {
WriteInt( trace.edges[j].v[0] );
WriteInt( trace.edges[j].v[1] );
WriteVec3( trace.edges[j].normal );
}
WriteInt( trace.numPolys );
for ( j = 0; j < MAX_TRACEMODEL_POLYS; j++ ) {
WriteVec3( trace.polys[j].normal );
WriteFloat( trace.polys[j].dist );
WriteBounds( trace.polys[j].bounds );
WriteInt( trace.polys[j].numEdges );
for ( k = 0; k < MAX_TRACEMODEL_POLYEDGES; k++ ) {
WriteInt( trace.polys[j].edges[k] );
}
}
WriteVec3( trace.offset );
WriteBounds( trace.bounds );
WriteBool( trace.isConvex );
// padding win32 native structs
char tmp[3];
memset( tmp, 0, sizeof( tmp ) );
file->Write( tmp, 3 );
}
void CIni::SerGetBool( bool bGet,bool & b, LPCTSTR strEntry,LPCTSTR strSection/* = NULL*/,bool bDefault/* = false*/)
{
if(bGet)
b = GetBool(strEntry,bDefault/*=NULL*/,strSection/* = NULL*/);
else
WriteBool(strEntry,b, strSection/* = NULL*/);
}
void CNodedMemoryBuffer::WriteBoolField(int iFieldId, BOOL bVal)
{
ASSERT(IsStoring());
WriteInt(iFieldId);
WriteDword(sizeof(BOOL));
WriteBool(bVal);
}
int main (void)
{
printf ("Hello World\n");
OpenIniFile ("Test.Ini");
#ifdef INIFILE_TEST_READ_AND_WRITE
WriteString ("Test", "Name", "Value");
WriteString ("Test", "Name", "OverWrittenValue");
WriteString ("Test", "Port", "COM1");
WriteString ("Test", "User", "James Brown jr.");
WriteString ("Configuration", "eDriver", "MBM2.VXD");
WriteString ("Configuration", "Wrap", "LPT.VXD");
WriteInt ("IO-Port", "Com", 2);
WriteBool ("IO-Port", "IsValid", 0);
WriteDouble ("TheMoney", "TheMoney", 67892.00241);
WriteInt ("Test" , "ToDelete", 1234);
WriteIniFile ("Test.Ini");
printf ("Key ToDelete created. Check ini file. Any key to continue");
while (!kbhit());
OpenIniFile ("Test.Ini");
DeleteKey ("Test" , "ToDelete");
WriteIniFile ("Test.Ini");
#endif
printf ("[Test] Name = %s\n", ReadString ("Test", "Name", "NotFound"));
printf ("[Test] Port = %s\n", ReadString ("Test", "Port", "NotFound"));
printf ("[Test] User = %s\n", ReadString ("Test", "User", "NotFound"));
printf ("[Configuration] eDriver = %s\n", ReadString ("Configuration", "eDriver", "NotFound"));
printf ("[Configuration] Wrap = %s\n", ReadString ("Configuration", "Wrap", "NotFound"));
printf ("[IO-Port] Com = %d\n", ReadInt ("IO-Port", "Com", 0));
printf ("[IO-Port] IsValid = %d\n", ReadBool ("IO-Port", "IsValid", 0));
printf ("[TheMoney] TheMoney = %1.10lf\n", ReadDouble ("TheMoney", "TheMoney", 111));
CloseIniFile ();
return 0;
}
void CIni::SerGetBool( BOOL bGet,BOOL & b, CString strEntry,LPCSTR strSection/* = NULL*/,BOOL bDefault/* = FALSE*/)
{
if (bGet)
b = GetBool(strEntry,bDefault/*=NULL*/,strSection/* = NULL*/);
else
WriteBool(strEntry,b, strSection/* = NULL*/);
}