int main()
{
int i; //loop counter
//header
printf("MECH 7171 Engineering programming %c\n",179);
printf("Lab #4 %c\n",179);
printf("Mark Naismith, A00819714, Set 5B %c\n",179);
printf("Cyrus Ang, A00781218, Set 5B %c\n",179);
printf("Corbin Turner, A00780890, Set 5B %c\n",179);
printf("December 6, 2013 %c\n",179);
printf("This program reads data from a data.txt file and %c\n",179);
printf("stores the data in a structure within the program%c\n",179);
printf("that is transfered between modular functions. %c\n",179);
printf("The tasks that this program completes are the %c\n",179);
printf("analytical solution to 2D conductive %c\n",179);
printf("heat transfer probrlems as well as %c\n",179);
printf("the numerical solutions. The end result is a %c\n",179);
printf("given heat transfer problem %c\n",179);
printf("that is solved numerically. %c\n",179);
//this loop "closes the box" of the header. Run program for details.
for(i=0;i<49;i++)printf("%c",196);
printf("%c\n",217);
//creation of the structure for simulations. Holds all relevant data
PROGRAMDATA pd;
//File stream pointer for the input file. This will be passed to the GetProgramData
//function for every simulation
FILE *f;
//Opens stream to the input file. Read only
f=fopen(DATA_FILENAME, "r");
//Check to see if the file exists, if not, exits function, main() complains
if(f==NULL)
{
printf("Input file \"%s\" doesn't exist! Exiting...",DATA_FILENAME);
getchar();
return 5;
}
i = 0;
//The proceding blocks are all very similar. Only the first will be explained.
do{
i++;
pd = GetProgramData(f);
if (pd.run == 1)//Checks to see if user wants to run
{
printf("\nRunning Simulation %d :\n", i);
simulate(pd);
}
} while (pd.run != -1);
// closes data file once all simulations are complete
//(could be closed before Given problem)
fclose(f);
//End Program
printf("Press Enter to end the program....");
fflush(stdin);//needed if the last file needed to be overwriten.
getchar();
return 0;
}
bool csShaderGLAVP::LoadProgramStringToGL ()
{
if (!shaderPlug->ext)
return false;
const csGLExtensionManager* ext = shaderPlug->ext;
if(!ext->CS_GL_ARB_vertex_program)
return false;
csRef<iDataBuffer> data = programBuffer;
if (!data)
data = GetProgramData();
if (!data)
return false;
//step to first !!
const char* programstring = (char*)data->GetData ();
size_t stringlen = data->GetSize ();
size_t i=0;
while (*programstring != '!' && i<stringlen)
{
++programstring;
++i;
}
stringlen -= i;
ext->glGenProgramsARB(1, &program_num);
ext->glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_num);
ext->glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
(GLsizei)stringlen, (void*) programstring);
const GLubyte * programErrorString = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
GLint errorpos;
glGetIntegerv (GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
if(errorpos != -1)
{
int realErrorPos = 0;
while (errorpos > 0)
{
if (programstring[realErrorPos] == '#')
{
while (programstring[realErrorPos] != '\n')
realErrorPos++;
}
errorpos--;
realErrorPos++;
}
CS_ALLOC_STACK_ARRAY (char, errorStart, strlen (programstring) + 1);
strcpy (errorStart, programstring);
char* start = errorStart + realErrorPos;
/*while (start > errorStart)
{
if (*(start - 1) == '\n')
{
break;
}
start--;
}*/
char* end = strchr (start, '\n');
if (end)
*(end-1) = 0;
if (doVerbose)
{
Report (CS_REPORTER_SEVERITY_WARNING,
"Couldn't load vertex program %s", CS::Quote::Double (description.GetDataSafe ()));
Report (CS_REPORTER_SEVERITY_WARNING, "Program error at: %s", CS::Quote::Double (start));
Report (CS_REPORTER_SEVERITY_WARNING, "Error string: %s",
CS::Quote::Single ((const char*)programErrorString));
}
return false;
}
bool csShaderGLCGCommon::WriteToCacheWorker (iHierarchicalCache* cache,
const ProfileLimits& limits, const ProfileLimitsPair& limitsPair,
const char* tag, const ProgramObject& program,
csString& failReason)
{
if (!cache) return false;
csMemFile cacheFile;
uint32 diskMagic = csLittleEndian::UInt32 (cacheFileMagic);
if (cacheFile.Write ((char*)&diskMagic, sizeof (diskMagic))
!= sizeof (diskMagic))
{
failReason = "write error (magic)";
return false;
}
csRef<iDataBuffer> programBuffer = GetProgramData();
CS::Utility::Checksum::MD5::Digest progHash = CS::Utility::Checksum::MD5::Encode (
programBuffer->GetData(), programBuffer->GetSize());
if (cacheFile.Write ((char*)&progHash, sizeof (progHash))
!= sizeof (progHash))
{
failReason = "write error (hash)";
return false;
}
if (!program.IsValid())
{
uint32 diskState = csLittleEndian::UInt32 (cpsInvalid);
if (cacheFile.Write ((char*)&diskState, sizeof (diskState))
!= sizeof (diskState))
{
failReason = "write error (state-invalid)";
return false;
}
}
else
{
{
uint32 diskState = csLittleEndian::UInt32 (cpsValid);
if (cacheFile.Write ((char*)&diskState, sizeof (diskState))
!= sizeof (diskState))
{
failReason = "write error (state-valid)";
return false;
}
}
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile, description);
CS_ASSERT(!program.GetID().archive.IsEmpty());
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile,
program.GetID().archive);
CS_ASSERT(!program.GetID().item.IsEmpty());
CS::PluginCommon::ShaderCacheHelper::WriteString (&cacheFile,
program.GetID().item);
}
csString cacheName ("/");
cacheName += tag;
if (!cache->CacheData (cacheFile.GetData(), cacheFile.GetSize(),
cacheName))
{
failReason = "failed writing to cache";
return false;
}
return true;
}
iShaderProgram::CacheLoadResult csShaderGLCGCommon::LoadFromCache (
iHierarchicalCache* cache, iBase* previous, iDocumentNode* node,
csRef<iString>* failReason, csRef<iString>* tag,
ProfileLimitsPair* cacheLimits)
{
if (!cache) return iShaderProgram::loadFail;
csRef<iShaderProgramCG> prevCG (scfQueryInterfaceSafe<iShaderProgramCG> (
previous));
csRef<iStringArray> allCachedPrograms;
if ((programType == progVP) && prevCG.IsValid())
{
csShaderGLCGFP* prevFP = static_cast<csShaderGLCGFP*> (
(iShaderProgramCG*)prevCG);
csString tagStr ("CG");
tagStr += prevFP->cacheLimits.ToString();
if (failReason) failReason->AttachNew (
new scfString ("paired cached programs not found"));
allCachedPrograms.AttachNew (new scfStringArray);
allCachedPrograms->Push (tagStr);
}
else
allCachedPrograms = cache->GetSubItems ("/");
if (!allCachedPrograms.IsValid() || (allCachedPrograms->GetSize() == 0))
{
if (failReason) failReason->AttachNew (
new scfString ("no cached programs found"));
return iShaderProgram::loadFail;
}
if (!GetProgramNode (node)) return iShaderProgram::loadFail;
csRef<iDataBuffer> programBuffer = GetProgramData();
CS::Utility::Checksum::MD5::Digest progHash = CS::Utility::Checksum::MD5::Encode (
programBuffer->GetData(), programBuffer->GetSize());
csArray<CachedShaderWrapper> cachedProgWrappers;
for (size_t i = 0; i < allCachedPrograms->GetSize(); i++)
{
const char* tag = allCachedPrograms->Get (i);
if ((tag[0] != 'C') || (tag[1] != 'G')) continue;
CachedShaderWrapper wrapper;
if (!wrapper.limits.FromString (tag+2)) continue;
wrapper.name = tag;
csString cachePath ("/");
cachePath.Append (tag);
csRef<iDataBuffer> cacheBuf = cache->ReadCache (cachePath);
if (!cacheBuf.IsValid()) continue;
csRef<iFile> cacheFile;
cacheFile.AttachNew (new csMemFile (cacheBuf, true));
wrapper.cacheFile = cacheFile;
uint32 diskMagic;
if (cacheFile->Read ((char*)&diskMagic, sizeof (diskMagic))
!= sizeof (diskMagic)) continue;
if (csLittleEndian::UInt32 (diskMagic) != cacheFileMagic)
continue;
CS::Utility::Checksum::MD5::Digest diskHash;
if (cacheFile->Read ((char*)&diskHash, sizeof (diskHash))
!= sizeof (diskHash)) continue;
if (diskHash != progHash) continue;
cachedProgWrappers.Push (wrapper);
}
if (cachedProgWrappers.GetSize() == 0)
{
if (failReason && !*failReason) failReason->AttachNew (
new scfString ("all cached programs failed to read"));
return iShaderProgram::loadFail;
}
cachedProgWrappers.Sort ();
ProfileLimits currentLimits (
(programType == progVP) ? shaderPlug->currentLimits.vp
: shaderPlug->currentLimits.fp);
bool strictMatch = (programType == progVP) ? shaderPlug->strictMatchVP
: shaderPlug->strictMatchFP;
const char* progTypeNode = 0;
switch (programType)
{
case progVP: progTypeNode = "cgvp"; break;
case progFP: progTypeNode = "cgfp"; break;
}
csString allReasons;
bool oneReadCorrectly = false;
ProfileLimits bestLimits (
CS::PluginCommon::ShaderProgramPluginGL::Other,
CG_PROFILE_UNKNOWN);
bool bestLimitsSet = false;
for (size_t i = cachedProgWrappers.GetSize(); i-- > 0;)
{
const CachedShaderWrapper& wrapper = cachedProgWrappers[i];
const ProfileLimits& limits =
(programType == progVP) ? wrapper.limits.vp : wrapper.limits.fp;
if (!bestLimitsSet)
{
bestLimits = limits;
bestLimitsSet = true;
}
if (strictMatch && (limits != currentLimits))
{
allReasons += wrapper.name;
allReasons += ": strict mismatch; ";
continue;
}
bool profileSupported =
(shaderPlug->ProfileNeedsRouting (limits.profile)
&& shaderPlug->IsRoutedProfileSupported (limits.profile))
|| cgGLIsProfileSupported (limits.profile);
if (!profileSupported)
{
allReasons += wrapper.name;
allReasons += ": Profile unsupported; ";
continue;
}
if ((limits.vendor != currentLimits.vendor)
&& (limits.vendor != CS::PluginCommon::ShaderProgramPluginGL::Other))
{
allReasons += wrapper.name;
allReasons += ": vendor mismatch; ";
continue;
}
bool limitsSupported = currentLimits >= limits;
if (!limitsSupported)
{
allReasons += wrapper.name;
allReasons += ": Limits exceeded; ";
continue;
}
iFile* cacheFile = wrapper.cacheFile;
{
uint32 diskState;
if (cacheFile->Read ((char*)&diskState, sizeof (diskState))
!= sizeof (diskState)) continue;
if (csLittleEndian::UInt32 (diskState) != cpsValid)
{
oneReadCorrectly = true;
continue;
}
}
description = CS::PluginCommon::ShaderCacheHelper::ReadString (cacheFile);
bool breakFail = false;
csRef<iDocumentNode> cgNode = node->GetNode (progTypeNode);
if (!cgNode.IsValid()) continue;
csRef<iDocumentNodeIterator> nodes = cgNode->GetNodes();
while(nodes->HasNext() && !breakFail)
{
csRef<iDocumentNode> child = nodes->Next();
if(child->GetType() != CS_NODE_ELEMENT) continue;
const char* value = child->GetValue ();
csStringID id = xmltokens.Request (value);
switch(id)
{
case XMLTOKEN_VARIABLEMAP:
if (!ParseVmap (child))
breakFail = true;
break;
case XMLTOKEN_CLIP:
if (!ParseClip (child))
breakFail = true;
break;
default:
/* Ignore unknown nodes. Invalid nodes would have been caught
by the first (not from cache) parsing */
break;
}
}
if (breakFail) continue;
csString objectCodeCachePathArc =
CS::PluginCommon::ShaderCacheHelper::ReadString (cacheFile);
if (objectCodeCachePathArc.IsEmpty()) continue;
csString objectCodeCachePathItem =
CS::PluginCommon::ShaderCacheHelper::ReadString (cacheFile);
if (objectCodeCachePathItem.IsEmpty()) continue;
ProgramObjectID progId (objectCodeCachePathArc, objectCodeCachePathItem);
ProgramObject programObj;
//if (!LoadObjectCodeFromCompileCache (limits, cache))
if (!shaderPlug->progCache.LoadObject (progId, programObj))
continue;
oneReadCorrectly = true;
if (program)
{
cgDestroyProgram (program);
program = 0;
}
if (!programObj.IsValid()) continue;
cgGetError(); // Clear error
program = cgCreateProgram (shaderPlug->context,
CG_OBJECT, programObj.GetObjectCode(), limits.profile, 0, 0);
if (!program) continue;
CGerror err = cgGetError();
if (err != CG_NO_ERROR)
{
const char* errStr = cgGetErrorString (err);
shaderPlug->Report (CS_REPORTER_SEVERITY_WARNING,
"Cg error %s", errStr);
continue;
}
programProfile = limits.profile;
programPositionInvariant = programObj.GetFlags() & ProgramObject::flagPositionInvariant;
unusedParams = programObj.GetUnusedParams();
ClipsToVmap();
GetParamsFromVmap();
bool doLoadToGL = !shaderPlug->ProfileNeedsRouting (programProfile);
cgGetError(); // Clear error
if (doLoadToGL)
{
cgGLLoadProgram (program);
}
else
{
cgCompileProgram (program);
}
shaderPlug->PrintAnyListing();
err = cgGetError();
if ((err != CG_NO_ERROR)
|| (doLoadToGL && !cgGLIsProgramLoaded (program)))
{
//if (shaderPlug->debugDump)
//DoDebugDump();
const char* errStr = cgGetErrorString (err);
shaderPlug->Report (CS_REPORTER_SEVERITY_WARNING,
"Cg error %s", errStr);
if (shaderPlug->doVerbose
&& (((programType == progVP) && (programProfile >= CG_PROFILE_ARBVP1))
|| ((programType == progFP) && (programProfile >= CG_PROFILE_ARBFP1))))
{
const char* err = (char*)glGetString (GL_PROGRAM_ERROR_STRING_ARB);
shaderPlug->Report (CS_REPORTER_SEVERITY_WARNING,
"OpenGL error string: %s", err);
}
shaderPlug->SetCompiledSource (0);
continue;
}
GetPostCompileParamProps ();
if (shaderPlug->debugDump)
DoDebugDump();
tag->AttachNew (new scfString (wrapper.name));
if (cacheLimits != 0)
*cacheLimits = wrapper.limits;
bool loaded = !shaderPlug->ProfileNeedsRouting (programProfile)
|| LoadProgramWithPS1 ();
if (loaded && (bestLimits < currentLimits))
{
/* The best found program is worse than the current limits, so pretend
that the shader program failed (instead just being 'invalid') -
that will make xmlshader try to load the program from scratch,
ie with current limits, which may just work. */
if (failReason)
failReason->AttachNew (new scfString ("Provoking clean load with current limits"));
return iShaderProgram::loadFail;
}
return loaded ? iShaderProgram::loadSuccessShaderValid
: iShaderProgram::loadSuccessShaderInvalid;
}
if (oneReadCorrectly)
{
if (bestLimits < currentLimits)
{
/* The 'invalid' programs may compile with the current limits -
so again, provoke clean load */
if (failReason)
failReason->AttachNew (new scfString ("Provoking clean load with current limits"));
return iShaderProgram::loadFail;
}
else
return iShaderProgram::loadSuccessShaderInvalid;
}
else
return iShaderProgram::loadFail;
}
void ShowProgramDatacfg(int person)
{
FILE *fp;
char buffer[257], buffer2[513], command[81], command2[81],
command3[81], command4[81], temp[2];
int i;
if(fp=fopen("NiKom:Datocfg/ProgramData.cfg", "r"))
{
while(!feof(fp))
{
buffer[0] = NULL, buffer2[0] = command[0] = NULL;
fgets(buffer,256,fp);
buffer[strlen(buffer)-1] = NULL;
i = 0;
while(i<strlen(buffer))
{
if(buffer[i] != '%')
{
if(buffer2[0] = NULL)
{
buffer2[0] = buffer[i];
buffer2[1] = NULL;
}
else
{
temp[0] = buffer[i];
temp[1] = NULL;
strcat(buffer2,temp);
}
}
else
{
if(buffer[i+1] == '%' || buffer[i+1] == NULL)
{
strcat(buffer2, "%");
if(buffer[i+1] != NULL)
i++;
}
else
{
command[0] = command2[0] = NULL;
command3[0] = NULL, command4[0] = NULL;
while(buffer[++i] != '%' && buffer[i] != NULL)
{
if(buffer[i] != '|')
{
if(command[0] == NULL)
{
command[0] = buffer[i];
command[1] = NULL;
}
else
{
temp[0] = buffer[i];
temp[1] = NULL;
strcat(command, temp);
}
}
else
{
while(buffer[++i] != '%' && buffer[i] != NULL)
{
if(command2[0] == NULL)
{
command2[0] = buffer[i];
command2[1] = NULL;
}
else
{
temp[0] = buffer[i];
temp[1] = NULL;
strcat(command2, temp);
}
}
if(buffer[++i] != NULL)
{
while(buffer[i] != ',' && buffer[i] != NULL)
{
if(command3[0] == NULL)
{
command3[0] = buffer[i];
command3[1] = NULL;
}
else
{
temp[0] = buffer[i];
temp[1] = NULL;
strcat(command3, temp);
}
i++;
}
while(buffer[i] != '%' && buffer[i] != NULL)
{
if(command4[0] == NULL)
{
command4[0] = buffer[i];
command4[1] = NULL;
}
else
{
temp[0] = buffer[i];
temp[1] = NULL;
strcat(command4, temp);
}
i++;
}
}
}
}
if(buffer2[0] != NULL)
{
puttekn(buffer2,-1);
buffer2[0] = NULL;
}
if(command && command2)
{
if(command3[0] == NULL)
{
puttekn(GetProgramData(person, NULL, command, command2), -1);
puttekn("\n\r", -1);
}
else
{
if(atoi(GetProgramData(person, NULL, command, command2)))
puttekn(command3, -1);
else
puttekn(command4, -1);
puttekn("\n\r", -1);
i = strlen(buffer);
}
}
printf("Command = !%s!, command2 = !%s!, command3 = !%s!, command4 = !%s!\n", command, command2, command3, command4);
}
}
if(buffer2[0] != NULL)
puttekn(buffer2,-1);
i++;
}
}
fclose(fp);
puttekn("\n\r", -1);
}
}
