Example #1
0
void SceneParser::parseFile() {
	//
	// at the top level, the scene can have a camera, 
	// background color and a group of objects
	// (we add lights and other things in future assignments)
	//
	char token[MAX_PARSER_TOKEN_LENGTH];
	while (getToken(token)) {
		if (!strcmp(token, "OrthographicCamera")) {
			parseOrthographicCamera();
		}
		else if (!strcmp(token, "PerspectiveCamera")) {
			parsePerspectiveCamera();
		}
		else if (!strcmp(token, "Background")) {
			parseBackground();
		}
		else if (!strcmp(token, "Lights")) {
			parseLights();
		}
		else if (!strcmp(token, "Materials")) {
			parseMaterials();
		}
		else if (!strcmp(token, "Group")) {
			group = parseGroup();
		}
		else {
			printf("Unknown token in parseFile: '%s'\n", token);
			exit(0);
		}
	}
}
void XMLParserMap::parse(DataUnion& data) {
    StructMap* result = new StructMap();
    
    //get root node
    tinyxml2::XMLElement* detailsMap = doc->FirstChildElement("map");
    if (detailsMap == nullptr) {
        std::cout << "Vacio" << std::endl;
    }
    
    uint width;
    uint height;
    width = detailsMap->IntAttribute("width");
    height = detailsMap->IntAttribute("height");

    result->numberColumns = width;
    result->numberRows = height;

    result->tileWidth = detailsMap->IntAttribute("tilewidth");
    result->tileHeight = detailsMap->IntAttribute("tileheight");

    //for every layer map...
    tinyxml2::XMLElement* layer = detailsMap->FirstChildElement("layer");
    while (layer) {
        const char* nameLayer = layer->Attribute("name");
        if (strcmp(nameLayer, "Background") == 0) {
            parseBackground(result, layer);
            
        } else if (strcmp(nameLayer, "Underground") == 0) {
            parseUnderground(result, layer);
        }
        layer = layer->NextSiblingElement("layer");
    }
    
    data.map=result;
}
Example #3
0
void scene::parse(const char *filename)
{
    //some default values in case parsing fails
    myObjGroup = NULL;
    bgColor = Vec3f(0.5,0.5,0.5);
    ambLight = Vec3f(0.5,0.5,0.5);
    eye = Vec3f(0,0,0);
    lookAt = Vec3f(0,0,-1);
    up = Vec3f(0,1,0);
    fovy = 45;
    file = NULL;
    curline = 1;

    //the file-extension needs to be "ray"
    assert(filename != NULL);
    const char *ext = &filename[strlen(filename)-4];
    assert(!strcmp(ext,".ray"));
    fopen_s(&file, filename, "r");
    assert(file != NULL);

    char token[MAX_PARSER_TOKEN_LENGTH];

    //prime the parser pipe
    parse_char = fgetc(file);

    while (getToken(token))
    {
        if(!strcmp(token, "Background"))
            parseBackground();
        else if(!strcmp(token, "Camera"))
            parseCamera();
        else if(!strcmp(token, "Materials"))
            parseMaterials();
        else if(!strcmp(token, "Group"))
            myObjGroup = parseGroup();
        else if(!strcmp(token, "Lights"))
            parseLights();
        else
        {
            cout<<"Unknown token in parseFile: '"<<token<<
                "' at input line "<<curline<<"\n";
            exit(-1);
        }
    }
}
Example #4
0
ParsedElement
Animxmlparser::parseNext ()
{
  ParsedElement parsedElement;
  parsedElement.type = XML_INVALID;
  parsedElement.version = m_version;
  parsedElement.isWpacket = false;

  if (m_reader->atEnd () || m_reader->hasError ())
    {
      m_parsingComplete = true;
      m_traceFile->close ();
      return parsedElement;
    }



  QXmlStreamReader::TokenType token =  m_reader->readNext ();
  if (token == QXmlStreamReader::StartDocument)
    return parsedElement;

  if (token == QXmlStreamReader::StartElement)
    {
      if (m_reader->name () == "anim")
        {
          parsedElement = parseAnim ();
        }
      if (m_reader->name () == "topology")
        {
          parsedElement = parseTopology ();
        }
      if (m_reader->name () == "node")
        {
          parsedElement = parseNode ();
        }
      if (m_reader->name () == "packet")
        {
          parsedElement = parsePacket ();
        }
      if (m_reader->name () == "p")
        {
          parsedElement = parseP ();
        }
      if (m_reader->name () == "wp")
        {
          parsedElement = parseWp ();
        }
      if (m_reader->name () == "wpacket")
        {
          parsedElement = parseWPacket ();
        }
      if (m_reader->name () == "link")
        {
          parsedElement = parseLink ();
        }
      if (m_reader->name () == "nonp2plinkproperties")
        {
          parsedElement = parseNonP2pLink ();
        }
      if (m_reader->name () == "linkupdate")
        {
          parsedElement = parseLinkUpdate ();
        }
      if (m_reader->name () == "nu")
        {
          parsedElement = parseNodeUpdate ();
        }
      if (m_reader->name () == "res")
        {
          parsedElement = parseResource ();
        }
      if (m_reader->name () == "bg")
        {
          parsedElement = parseBackground ();
        }
      if (m_reader->name () == "ncs")
        {
          parsedElement = parseCreateNodeCounter ();
        }
      if (m_reader->name () == "nc")
        {
          parsedElement = parseNodeCounterUpdate ();
        }
      if (m_reader->name () == "pr")
        {
          parsedElement = parsePacketTxRef ();
        }
      if (m_reader->name () == "wpr")
        {
          parsedElement = parseWPacketRxRef ();
        }
      //qDebug (m_reader->name ().toString ());
    }

  if (m_reader->atEnd ())
    {
      m_parsingComplete = true;
      m_traceFile->close ();
    }
  return parsedElement;
}
// Parse out backgrounds
int parseBackgrounds(TiXmlElement *zbeXML, FILE *output)
{
	// Total # backgrounds.
	fpos_t totalBgPos = tempVal<uint32_t>("Total Backgrounds", output);
	uint32_t totalBg = 0;

	// For all the backgrounds in the XML file
	TiXmlElement *bgsXML = zbeXML->FirstChildElement("backgrounds");
	if (bgsXML)
	{
		TiXmlElement *bgXML = bgsXML->FirstChildElement("background");
		while (bgXML)
		{
			// Increment total bg counter
			++totalBg;

			// Get the palette to use for this background
			uint32_t pal = 0;
			bool defPal = false;
			int palVal;
			if (!getIntAttr(bgXML, "palette", palVal))
				fprintf(stderr, "WARNING: No default palette defined for background #%d.\n", totalBg);
			else
			{
				pal = (uint32_t) palVal;
				defPal = true;
			}

			// See if there's an xml attribute defined
			string extBgXMLfile = getStrAttr(bgXML, "xml");
			string extBgBINfile = getStrAttr(bgXML, "bin");
			if (!extBgXMLfile.empty())
			{
				debug("\tOpening external background map XML file: %s\n", extBgXMLfile.c_str());
				TiXmlDocument extXML(extBgXMLfile.c_str());
				if (!extXML.LoadFile())
				{
					fprintf(stderr, "Failed to parse file %s\n", extBgXMLfile.c_str());
					exit(EXIT_FAILURE);
				}
				TiXmlElement *extBgXML = extXML.RootElement()->FirstChildElement("backgroundmap");

				parseBackground(extBgXML, output, totalBg, pal, defPal);
			}
			// See if the map was added as a grit-generated bin
			else if (!extBgBINfile.empty())
			{
				
				// Get dimensions of the map
				int width, height;
				if (!getIntAttr(bgXML, "w", width))
				{
					fprintf(stderr, "ERROR: no width provided for background %d.\n", totalBg);
					exit(EXIT_FAILURE);
				}
				if (!getIntAttr(bgXML, "h", height))
				{
					fprintf(stderr, "ERROR: no height provided for background %d.\n", totalBg);
					exit(EXIT_FAILURE);
				}
				if (!defPal)
				{
					fprintf(stderr, "ERROR: no palette provided for background %d.\n", totalBg);
				}
				
				debug("\tInserting external %d x %d background map BIN file %s using palette #%d\n", width, height, extBgBINfile.c_str(), pal);
				// dimensions
				fwrite<uint32_t>(uint32_t(width), output);
				fwrite<uint32_t>(uint32_t(height), output);
				
				// palettes
				fwrite<uint8_t>(1, output);
				fwrite<uint32_t>(pal, output);
				
				// temp data length followed by data
				fpos_t dataLenPos = tempVal<uint32_t>("Map Data Length", output);
				uint32_t dataLen = appendData(output, extBgBINfile);
				goWrite<uint32_t>(dataLen, output, &dataLenPos);
				debug("\tWrote %dB of map data.\n", dataLen);
			}
			else
				parseBackground(bgXML, output, totalBg, pal, defPal);

			// Get the next sibling
			bgXML = bgXML->NextSiblingElement("background");
			debug("Background Done\n");
		}
	}
	// Now that the total number of backgrounds are known, go back and write that down
	goWrite<uint32_t>(totalBg, output, &totalBgPos);
	debug("%d Backgrounds Processed\n\n", int(totalBg));
	return totalBg;
}