void SceneParser::parseTransform(Shape* s)
{
if(currentToken != Scanner::Id || scanner.tokenText() != "transform")
return;
parseToken(Scanner::LeftCurly);
advance();
while(errorFlag == false && currentToken == Scanner::Id)
{
string tokenText = scanner.tokenText();
if(tokenText == "translate"){
Vector3 factor;
parseVector(factor);
s->Translate(factor);
}
else if(tokenText == "rotate"){
Vector3 factor;
parseVector(factor);
s->Rotate(factor);
}
else if(tokenText == "scale"){
Vector3 factor;
parseVector(factor);
s->Scale(factor);
}
else
error("undefined transform attribute \"" + tokenText + "\"");
advance();
}
acceptToken(Scanner::RightCurly);
advance();
}
void SceneParser::parseSpotlight(void)
{
parseToken(Scanner::LeftCurly);
Vector3 pos;
parseVector(pos);
Vector3 lookat;
parseVector(lookat);
Vector3 color;
parseVector(color);
Vector3 falloff;
parseVector(falloff);
float intensity;
parseNumber(intensity);
float innerAngle;
parseNumber(innerAngle);
float outerNumber;
parseNumber(outerNumber);
Light* l = new Spotlight(raytracer, pos, lookat, color, falloff, intensity, innerAngle, outerNumber);
raytracer->addLight(l);
parseToken(Scanner::RightCurly);
}
void SGOglTextureCoordNBPage::OnTextEnterObjCoeffT(wxCommandEvent &event)
{
SGFixedGLState* glState = m_parent->GetGLState();
glState->SetTextureChanged(true);
wxArrayString userEnteredValues;
vec4 objPlaneTVec;
if((parseVector(objectPlaneCoeffTextT->GetValue())).GetCount() == 4)
{
userEnteredValues = parseVector(objectPlaneCoeffTextT->GetValue());
for(int i = 0; i < 4; i++)
{
objPlaneTVec[i] = atof(userEnteredValues.Item(i).mb_str());
}
glState->GetTexture(texCoordUnitBox->GetSelection())->objectPlaneCoeffT = objPlaneTVec;
}
else
{
IncorrectFormat(wxT("four floating point values, with each value seperated by a comma."), *this);
return;
}
wxGetApp().GetFrame()->SetCanvasMode(0);
wxGetApp().GetFrame()->GetCanvas()->Update();
}
void SecondaryStructureRMSD::readBackboneAtoms( const std::string& moltype, std::vector<unsigned>& chain_lengths ){
std::vector<SetupMolInfo*> moldat=plumed.getActionSet().select<SetupMolInfo*>();
if( moldat.size()==0 ) error("Unable to find MOLINFO in input");
std::vector<std::string> resstrings; parseVector( "RESIDUES", resstrings );
if( !verbose_output ){
if(resstrings[0]=="all"){
log.printf(" examining all possible secondary structure combinations\n");
} else {
log.printf(" examining secondary struture in residue poritions : %s \n",resstrings[0].c_str() );
for(unsigned i=1;i<resstrings.size();++i) log.printf(", %s",resstrings[i].c_str() );
log.printf("\n");
}
}
std::vector< std::vector<AtomNumber> > backatoms;
moldat[0]->getBackbone( resstrings, moltype, backatoms );
chain_lengths.resize( backatoms.size() );
for(unsigned i=0;i<backatoms.size();++i){
chain_lengths[i]=backatoms[i].size();
for(unsigned j=0;j<backatoms[i].size();++j) all_atoms.push_back( backatoms[i][j] );
}
ActionAtomistic::requestAtoms( all_atoms );
forcesToApply.resize( getNumberOfDerivatives() );
}
unsigned long long TomKva_v5(char* aname, char* cname, int seconds)
{
FILE* afile = fopen(aname, "r");
FILE* cfile = fopen(cname, "r");
fm_count = 0;
if (afile == NULL)
{
fprintf(stderr, "could not open file A\n");
exit(1);
}
if (cfile == NULL)
{
fprintf(stderr, "could not open file c\n");
exit(1);
}
_matrix* matA = parseMatrix(afile);
_vector* vecC = parseVector(cfile);
fclose(afile);
fclose(cfile);
Arena* arena = init_arena_basic(6, 6);
if (seconds == 0)
{
/* Just run once for validation. */
// Uncomment when your function and variables exist...
int result = fm_elim(arena, matA->rows, matA->columns, matA->cells, vecC->elements);
free_up(matA,vecC);
destroy_arena(arena);
return result;
//return 1; // return one, i.e. has a solution for now...
}
/* Tell operating system to call function DONE when an ALARM comes. */
signal(SIGALRM, done);
alarm(seconds);
/* Now loop until the alarm comes... */
proceed = true;
while (proceed)
{
// Uncomment when your function and variables exist...
// fm_elim(rows, cols, a, c);
fm_elim(arena, matA->rows, matA->columns, matA->cells, vecC->elements);
fm_count++;
}
// Clean up
free_up(matA,vecC);
destroy_arena(arena);
return fm_count;
}
void SceneParser::parseCamera(void)
{
parseToken(Scanner::LeftCurly);
Vector3 o;
parseVector(o);
Vector3 p;
parseVector(p);
Vector3 u;
parseVector(u);
config.camera = new Camera(o, p, u, config.width, config.height);
parseToken(Scanner::RightCurly);
}
void SceneParser::parseDirectionalLight(void)
{
parseToken(Scanner::LeftCurly);
Vector3 dir;
parseVector(dir);
Vector3 color;
parseVector(color);
float intensity;
parseNumber(intensity);
Light* l = new DirectionalLight(raytracer, dir, color, intensity);
raytracer->addLight(l);
parseToken(Scanner::RightCurly);
}
void ActionAtomistic::parseAtomList(const std::string&key,const int num, std::vector<AtomNumber> &t){
plumed_massert( keywords.style(key,"atoms") || keywords.style(key,"hidden"), "keyword " + key + " should be registered as atoms");
vector<string> strings;
if( num<0 ){
parseVector(key,strings);
if(strings.empty()) return;
} else {
if ( !parseNumberedVector(key,num,strings) ) return;
}
interpretAtomList( strings, t );
}
void SceneParser::parseBox(void)
{
parseToken(Scanner::LeftCurly);
Vector3 minCorner;
parseVector(minCorner);
Vector3 maxCorner;
parseVector(maxCorner);
Box* b = new Box(minCorner, maxCorner);
raytracer->addObject(b);
advance();
parseMaterial(b);
parseTransform(b);
acceptToken(Scanner::RightCurly);
}
Vector ParticleComponentLoader::loadVector(const TiXmlElement& xmlElement, const char* pname)
{
Vector result;
std::string value;
if ( xmlElement.QueryStringAttribute(pname, &value) == TIXML_SUCCESS )
{
result = parseVector(value);
}
return result;
}
VectorRange ParticleComponentLoader::loadVectorRange(const TiXmlElement& xmlElement, const char* pname)
{
VectorRange result;
std::string value;
if ( xmlElement.QueryStringAttribute(pname, &value) == TIXML_SUCCESS )
{
std::size_t index = value.find(':');
if ( index != value.npos )
{
std::string leftrange = value.substr(0, index);
std::string rightrange = value.substr(index+1, value.length() - index - 1);
Vector left = parseVector(leftrange);
Vector right = parseVector(rightrange);
result.set(left, right);
}
}
return result;
}
DataObject::DataObject(QString val)
{
mValue = val.trimmed();
if (isVector()) {
mVector = parseVector(mValue);
} else if (is4x4Matrix()) {
m4x4Matrix = parse4x4Matrix(mValue);
} else if (isMatrix()) {
mMatrix = parseMatrix(mValue);
}
}
void SceneParser::parsePointLight(void)
{
parseToken(Scanner::LeftCurly);
Vector3 pos;
parseVector(pos);
Vector3 color;
parseVector(color);
Vector3 falloff;
parseVector(falloff);
float intensity;
parseNumber(intensity);
Light* l = new PointLight(raytracer, pos, color, falloff, intensity);
raytracer->addLight(l);
parseToken(Scanner::RightCurly);
}
void SceneParser::parsePlane(void)
{
parseToken(Scanner::LeftCurly);
Vector3 center;
parseVector(center);
Vector3 right;
parseVector(right);
Vector3 up;
parseVector(up);
Plane* p = new Plane(center, right, up);
raytracer->addObject(p);
advance();
parseMaterial(p);
parseTransform(p);
acceptToken(Scanner::RightCurly);
}
void SceneParser::parseTriangle(void)
{
parseToken(Scanner::LeftCurly);
Vector3* p1 = new Vector3();
parseVector(*p1);
Vector3* p2 = new Vector3();
parseVector(*p2);
Vector3* p3 = new Vector3();
parseVector(*p3);
Triangle* t = new Triangle(p1, p2, p3, true);
raytracer->addObject(t);
advance();
parseMaterial(t);
parseTransform(t);
acceptToken(Scanner::RightCurly);
}
std::vector< std::vector<double> > DataObject::parseMatrix(QString str)
{
QString sub = str.mid(1,str.length()-2);
QStringList ls = sub.split(QRegExp("\\] *, *\\["));
int n = ls.size();
std::vector< std::vector<double> > vec(n);
int index = 0;
QStringList::iterator iter;
for (iter = ls.begin() ;iter != ls.end() ; iter++) {
QString out = *iter;
vec[index++] = parseVector(out);
}
return vec;
}
void SceneParser::parseAreaLight(void)
{
parseToken(Scanner::LeftCurly);
Vector3 pos;
parseVector(pos);
Vector3 right;
parseVector(right);
Vector3 up;
parseVector(up);
Vector3 color;
parseVector(color);
Vector3 falloff;
parseVector(falloff);
float intensity;
parseNumber(intensity);
int samplesx;
parseNumber(samplesx);
int samplesy;
parseNumber(samplesy);
Light* l = new AreaLight(raytracer, pos, right, up, color, falloff, intensity, samplesx, samplesy);
raytracer->addLight(l);
Plane* p = new Plane(pos + up * 0.5f + right * 0.5f, right, right.getLength() / 2.0f, up, up.getLength() / 2.0f);
p->getMaterial().setEmissive(color * intensity);
raytracer->addObject(p);
parseToken(Scanner::RightCurly);
}
void Function::addValueWithDerivatives() {
plumed_massert( getNumberOfArguments()!=0, "for functions you must requestArguments before adding values");
ActionWithValue::addValueWithDerivatives();
getPntrToValue()->resizeDerivatives(getNumberOfArguments());
if( keywords.exists("PERIODIC") ) {
std::vector<std::string> period;
parseVector("PERIODIC",period);
if(period.size()==1 && period[0]=="NO") {
setNotPeriodic();
} else if(period.size()==2) {
setPeriodic(period[0],period[1]);
} else error("missing PERIODIC keyword");
}
}
QMatrix4x4 DataObject::parse4x4Matrix(QString str)
{
QString sub = str.mid(1,str.length()-2);
QStringList ls = sub.split(QRegExp("\\] *, *\\["));
QMatrix4x4 matrix;
int index = 0;
float* data = matrix.data();
QStringList::iterator iter;
for (iter = ls.begin() ;iter != ls.end() ; iter++) {
QString out = *iter;
std::vector<double> vd = parseVector(out);
data[index] = vd[0];
data[index+1] = vd[1];
data[index+2] = vd[2];
data[index+3] = vd[3];
index+=4;
}
return matrix;
}
HistogramOnGrid::HistogramOnGrid( const vesselbase::VesselOptions& da ):
GridVessel(da),
neigh_tot(0),
addOneKernelAtATime(false),
bandwidths(dimension),
discrete(false)
{
if( getType()=="flat" ) {
parse("KERNEL",kerneltype);
if( kerneltype=="discrete" || kerneltype=="DISCRETE" ) {
discrete=true;
setNoDerivatives();
} else {
parseVector("BANDWIDTH",bandwidths);
}
} else {
parse("CONCENTRATION",von_misses_concentration);
von_misses_norm = von_misses_concentration / ( 4*pi*sinh( von_misses_concentration ) );
}
}
bool ReferenceAtoms::parseAtomList( const std::string& key, std::vector<unsigned>& numbers ){
plumed_assert( numbers.size()==0 );
std::vector<std::string> strings;
if( !parseVector(key,strings,true) ) return false;
Tools::interpretRanges(strings);
numbers.resize( strings.size() );
for(unsigned i=0;i<strings.size();++i){
AtomNumber atom;
if( !Tools::convert(strings[i],atom ) ) error("could not convert " + strings[i] + " into atom number");
bool found=false;
for(unsigned j=0;j<indices.size();++j){
if( atom==indices[j] ){ found=true; numbers[i]=j; break; }
}
if(!found) error("atom labelled " + strings[i] + " is not present in pdb input file");
}
return true;
}
void SceneParser::parseSphere(void)
{
parseToken(Scanner::LeftCurly);
Vector3 center;
parseVector(center);
float radius;
parseNumber(radius);
Sphere* s = new Sphere(center, radius);
raytracer->addObject(s);
advance();
parseMaterial(s);
parseTransform(s);
acceptToken(Scanner::RightCurly);
}
void SceneParser::parseCylinder(void)
{
parseToken(Scanner::LeftCurly);
Vector3 base;
parseVector(base);
float height;
parseNumber(height);
float radius;
parseNumber(radius);
Cylinder* c = new Cylinder(base, height, radius);
raytracer->addObject(c);
advance();
parseMaterial(c);
parseTransform(c);
acceptToken(Scanner::RightCurly);
}
/**
* Parse the ship types.
*
* @return A map with ID's and shiptypes.
*/
std::map<std::string, ShipType> LevelReader::parseShipTypes() {
std::map<std::string, ShipType> shipTypes;
ticpp::Element* shipsNode = fLevel.FirstChild("level")->FirstChild("ships")->ToElement();
ticpp::Iterator<ticpp::Element> shipTypeNode("ship");
for (shipTypeNode = shipTypeNode.begin(shipsNode); shipTypeNode != shipTypeNode.end(); shipTypeNode++) {
std::string name = (*shipTypeNode).GetAttribute("name");
ticpp::Element* boundingshape = (*shipTypeNode).FirstChild("boundingshape")->ToElement();
IBoundingShapeDescription* shape;
parseBoundingShape(shape, boundingshape);
ticpp::Element* weaponsNode = shipTypeNode->FirstChild("weapons")->ToElement();
ticpp::Iterator<ticpp::Element> weaponNode("weapon");
std::vector<std::string> weapons;
for (weaponNode = weaponNode.begin(weaponsNode); weaponNode != weaponNode.end(); weaponNode++) {
weapons.push_back(weaponNode->GetAttribute("name"));
}
Vector2 speed = parseVector(shipTypeNode->FirstChild("maxspeed")->ToElement());
int hitpoints = shipTypeNode->GetAttribute<int>("hitpoints");
shipTypes[name] = ShipType(name, shape, weapons, speed, hitpoints);
}
return shipTypes;
}
GridPrintingBase::GridPrintingBase(const ActionOptions&ao):
Action(ao),
ActionPilot(ao),
fmt("%f"),
output_for_all_replicas(false)
{
std::string mlab; parse("GRID",mlab);
vesselbase::ActionWithVessel* mves= plumed.getActionSet().selectWithLabel<vesselbase::ActionWithVessel*>(mlab);
if(!mves) error("action labelled " + mlab + " does not exist or does not have vessels");
addDependency(mves);
for(unsigned i=0; i<mves->getNumberOfVessels(); ++i) {
ingrid=dynamic_cast<GridVessel*>( mves->getPntrToVessel(i) );
if( ingrid ) break;
}
if( !ingrid ) error("input action does not calculate a grid");
parse("FILE",filename);
if(filename.length()==0) error("name out output file was not specified");
log.printf(" outputting grid calculated by action %s to file named %s",mves->getLabel().c_str(), filename.c_str() );
if( keywords.exists("FMT") ) {
parse("FMT",fmt); log.printf(" with format %s \n", fmt.c_str() );
} else {
log.printf("\n");
}
std::vector<std::string> rep_data; parseVector("REPLICA",rep_data);
if( rep_data.size()==1 ) {
if( rep_data[0]=="all" ) output_for_all_replicas=true;
else {
preps.resize(1); Tools::convert( rep_data[0], preps[0] );
}
} else {
preps.resize( rep_data.size() );
for(unsigned i=0; i<rep_data.size(); ++i) Tools::convert( rep_data[i], preps[i] );
}
}
ActionWithAveraging::ActionWithAveraging( const ActionOptions& ao ):
Action(ao),
ActionPilot(ao),
ActionAtomistic(ao),
ActionWithArguments(ao),
ActionWithValue(ao),
ActionWithVessel(ao),
myaverage(NULL),
useRunAllTasks(false),
clearstride(0),
lweight(0),cweight(0)
{
if( keywords.exists("CLEAR") ) {
parse("CLEAR",clearstride);
if( clearstride>0 ) {
if( clearstride%getStride()!=0 ) error("CLEAR parameter must be a multiple of STRIDE");
log.printf(" clearing grid every %u steps \n",clearstride);
}
}
if( keywords.exists("LOGWEIGHTS") ) {
std::vector<std::string> wwstr; parseVector("LOGWEIGHTS",wwstr);
if( wwstr.size()>0 ) log.printf(" reweighting using weights from ");
std::vector<Value*> arg( getArguments() );
for(unsigned i=0; i<wwstr.size(); ++i) {
ActionWithValue* val = plumed.getActionSet().selectWithLabel<ActionWithValue*>(wwstr[i]);
if( !val ) error("could not find value named");
weights.push_back( val->copyOutput(val->getLabel()) );
arg.push_back( val->copyOutput(val->getLabel()) );
log.printf("%s ",wwstr[i].c_str() );
}
if( wwstr.size()>0 ) log.printf("\n");
else log.printf(" weights are all equal to one\n");
requestArguments( arg );
}
if( keywords.exists("UNORMALIZED") ) parseFlag("UNORMALIZED",unormalised);
}
GLLObjFile::GLLObjFile(CFURLRef location)
{
std::string filename = GLLStringFromFileURL(location);
int fdes = ::open(filename.c_str(), O_RDONLY);
if (fdes < 0) {
throw std::runtime_error("Could not open file");
}
struct stat statistics;
if (fstat(fdes, &statistics) < 0) {
close(fdes);
throw std::runtime_error("Could not get file size");
}
const char *buffer = (const char *) mmap(nullptr, statistics.st_size, PROT_READ, MAP_PRIVATE, fdes, 0);
close(fdes);
const char *current = buffer;
const char *end = &buffer[statistics.st_size];
materialLibraryURLs = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
std::string activeMaterial("");
unsigned activeMaterialStart = 0;
bool hasFirstMaterial = false;
while(current != end)
{
while (current != end && (*current == ' ' || *current == '\n' || *current == '\r')) {
current++;
}
if (current == end)
break;
switch (*current) {
case 'f':
parseFace(current, end);
break;
case 'v':
current += 1;
switch (*current) {
case 'n': // Normals
current += 1;
parseVector(current, end, normals, 3);
break;
case 't': // Tex coords
current += 1;
parseVector(current, end, texCoords, 2);
break;
case 'c': // Colors
current += 1;
parseVector(current, end, colors, 4);
break;
case ' ': // Vertex
parseVector(current, end, vertices, 3);
break;
default:
skipToEndOfLine(current, end);
break;
}
break;
case 'm':
if (followsString(current, end, "mtllib")) {
std::string mtllib = stringToEndOfLine(current, end);
try
{
CFURLRef mtllibLocation = GLLCreateURLFromString(mtllib, location);
CFArrayAppendValue(materialLibraryURLs, mtllibLocation);
CFRelease(mtllibLocation);
}
catch (std::exception &e)
{
std::cerr << "Ignoring mtllib: " << e.what() << std::endl;
}
} else {
skipToEndOfLine(current, end);
}
break;
case 'u':
if (followsString(current, end, "usemtl")) {
if (hasFirstMaterial)
{
// End previous material run
materialRanges.push_back(MaterialRange(activeMaterialStart, (unsigned) originalIndices.size(), activeMaterial));
}
else
hasFirstMaterial = true;
current += 1;
activeMaterial = stringToEndOfLine(current, end);
activeMaterialStart = (unsigned) originalIndices.size();
} else {
skipToEndOfLine(current, end);
}
break;
case '#': // Comment
default:
skipToEndOfLine(current, end);
break;
}
}
munmap((void *) buffer, statistics.st_size);
// Wrap up final material group
materialRanges.push_back(MaterialRange(activeMaterialStart, (unsigned) originalIndices.size(), activeMaterial));
fillIndices();
}
bool parseLineToFields(char* line, CFields& fields, const char* file, size_t line_number)
{
// format
if (line[0] == '{') {
line++;
if (!nullLast(line, '}') || !fields.parseFormat(line)) {
LCPrintf("Invalid format string at line %i in %s\n", line_number, file);
return false;
}
return false; // no data
}
char* argv[32];
size_t argc = parse(line, argv, arraysize(argv));
if (!argc || argc != fields.getCount()) {
LCPrintf("Invalid fields count at line %i in %s\n", line_number, file);
return false;
}
// data
for (size_t i = 0; i < fields.getCount(); i++) {
auto field = fields.getField(i);
switch (field->type) {
case dt_origin:
case dt_mins:
case dt_maxs:
case dt_lcorner:
case dt_hcorner:
if (!parseVector(argv[i], field->vec)) {
LCPrintf("Invalid vector data in field %i at line %i in %s\n", i, line_number, file);
return false;
}
break;
case dt_param:
case dt_value:
case dt_radio:
case dt_phrase:
case dt_translation:
strncpy(field->string, argv[i], sizeof field->string - 1);
field->string[sizeof field->string - 1] = '\0';
break;
case dt_menuid:
case dt_red:
case dt_green:
case dt_blue:
field->int_number = strtol(argv[i], nullptr, 10);
break;
case dt_xcoord:
case dt_ycoord:
field->float_number = strtod(argv[i], nullptr);
break;
default:
LCPrintf("Invalid field type %i (pos %i) at line %i in %s\n", field->type, i, line_number, file);
return false;
}
}
return true;
}
void SceneParser::parseMaterial(Shape* s)
{
if(currentToken != Scanner::Id || scanner.tokenText() != "material")
return;
parseToken(Scanner::LeftCurly);
advance();
while(errorFlag == false && currentToken == Scanner::Id)
{
string tokenText = scanner.tokenText();
if(tokenText == "diffuse"){
Vector3 diffuseColor;
parseVector(diffuseColor);
float coefficent;
parseNumber(coefficent);
s->getMaterial().setDiffuse(diffuseColor);
s->getMaterial().setDiffuseFactor(coefficent);
}
else if(tokenText == "specular"){
Vector3 color;
parseVector(color);
float coefficent;
parseNumber(coefficent);
s->getMaterial().setSpecularFactor(coefficent);
s->getMaterial().setSpecular(color);
}
else if(tokenText == "shine"){
float shineness;
parseNumber(shineness);
s->getMaterial().setShineness(shineness);
}
else if(tokenText == "reflect"){
Vector3 color;
parseVector(color);
float reflect;
parseNumber(reflect);
s->getMaterial().setReflectColor(color);
s->getMaterial().setReflective(reflect);
}
else if(tokenText == "glossyReflect"){
Vector3 color;
parseVector(color);
float reflect;
parseNumber(reflect);
float glossy;
parseNumber(glossy);
s->getMaterial().setReflectColor(color);
s->getMaterial().setReflective(reflect);
s->getMaterial().setGlossiness(glossy);
}
else if(tokenText == "refract"){
float refract;
parseNumber(refract);
float IOR;
parseNumber(IOR);
s->getMaterial().setRefraction(refract);
s->getMaterial().setIOR(IOR);
}
else if(tokenText == "glossyRefract"){
float refract;
parseNumber(refract);
float IOR;
parseNumber(IOR);
float glossy;
parseNumber(glossy);
s->getMaterial().setRefraction(refract);
s->getMaterial().setIOR(IOR);
s->getMaterial().setGlossiness(glossy);
}
else if(tokenText == "texture"){
parseToken(Scanner::String);
string fileName = scanner.tokenText();
parseToken(Scanner::Id);
string sampling = scanner.tokenText();
Texture::SamplingType samp;
if(sampling == "NEAREST")
samp = Texture::NEAREST;
else if(sampling == "BILINEAR")
samp = Texture::BILINEAR;
else
error("invalid texture filtering option: " + sampling);
parseToken(Scanner::Id);
string clamping = scanner.tokenText();
Texture::ClampingType clamp;
if(clamping == "CLAMP")
clamp = Texture::CLAMP;
else if(clamping == "REPEAT")
clamp = Texture::REPEAT;
else
error("invalid texture clamping option: " + clamping);
Texture* t = Texture::loadTexture(fileName, samp, clamp);
if(t == NULL)
error("Invalid file path \"" + fileName + "\"");
s->getMaterial().setTexture(t);
}
else if(tokenText == "bumpmap"){
parseToken(Scanner::String);
string fileName = scanner.tokenText();
Texture* t = Texture::loadTexture(fileName, Texture::NEAREST, Texture::REPEAT);
if(t == NULL)
error("Invalid file path \"" + fileName + "\"");
s->getMaterial().setBumpMap(t);
}
else if(tokenText == "normalmap"){
parseToken(Scanner::String);
string fileName = scanner.tokenText();
Texture* t = Texture::loadTexture(fileName, Texture::NEAREST, Texture::REPEAT);
if(t == NULL)
error("Invalid file path \"" + fileName + "\"");
s->getMaterial().setNormalMap(t);
}
else{
error("undefined material attribute \"" + tokenText + "\"");
}
advance();
}
acceptToken(Scanner::RightCurly);
advance();
}
void SceneParser::parseConfig(void)
{
if(currentToken == Scanner::StreamDone)
return;
else{
while(errorFlag == false && currentToken != Scanner::StreamDone)
{
if(currentToken == Scanner::Separator)
return;
acceptToken(Scanner::Id);
string tokenText = scanner.tokenText();
if(tokenText == "width"){
parseNumber(config.width);
}
else if(tokenText == "height"){
parseNumber(config.height);
}
else if(tokenText == "mode"){
parseToken(Scanner::Id);
string m = scanner.tokenText();
if(m == "standard")
config.mode = Config::STANDARD;
else if(m == "photon")
config.mode = Config::PHOTON;
else
error("invalid mode");
}
else if(tokenText == "gamma"){
float num;
parseNumber(num);
config.gamma = num;
}
else if(tokenText == "ambient"){
parseNumber(config.ambient);
}
else if(tokenText == "background"){
parseVector(config.backColor);
}
else if(tokenText == "depth"){
float depth;
parseNumber(depth);
config.reflectionDepth = depth;
}
else if(tokenText == "glossyReflectSampling"){
int sampling;
parseNumber(sampling);
config.glossyReflectSampling = sampling;
}
else if(tokenText == "glossyRefractSampling"){
int sampling;
parseNumber(sampling);
config.glossyRefractSampling = sampling;
}
else if(tokenText == "uniform"){
int level;
parseNumber(level);
config.sampler = new uniformSampler(raytracer, config, level);
}
else if(tokenText == "jitter"){
int level;
parseNumber(level);
config.sampler = new jitterSampler(raytracer, config, level);
}
else if(tokenText == "adaptive"){
int level;
parseNumber(level);
Vector3 threshold;
parseVector(threshold);
config.sampler = new adaptiveSampler(raytracer, config, level, threshold);
}
else if(tokenText == "camera"){
parseCamera();
}
else if(tokenText == "photon"){
parsePhoton();
}
else{
return;
}
advance();
}
}
}
