C++ PropertyList::getString方法代码示例

	WavefrontOBJ(const PropertyList &propList) {
		typedef boost::unordered_map<OBJVertex, uint32_t, OBJVertexHash> VertexMap;

		/* Process the OBJ-file line by line */	
		QString filename = propList.getString("filename");
		QFile input(filename);
		if (!input.open(QIODevice::ReadOnly | QIODevice::Text))
			throw NoriException(QString("Cannot open \"%1\"").arg(filename));

		Transform trafo = propList.getTransform("toWorld", Transform());

		cout << "Loading \"" << qPrintable(filename) << "\" .." << endl;
		m_name = filename;

		QTextStream stream(&input);
		QTextStream line;
		QString temp, prefix;

		std::vector<Point3f>   positions;
		std::vector<Point2f>   texcoords;
		std::vector<Normal3f>  normals;
		std::vector<uint32_t>  indices;
		std::vector<OBJVertex> vertices;
		VertexMap vertexMap;

		while (!(temp = stream.readLine()).isNull()) {
			line.setString(&temp);

			line >> prefix;
			if (prefix == "v") {
				Point3f p;
				line >> p.x() >> p.y() >> p.z();
				p = trafo * p;
				positions.push_back(p);
			} else if (prefix == "vt") {

    EnvMap(const PropertyList &props) :
        Emitter(props.getTransform("toWorld", Transform()))
    {
        //set the arguments
        std::string filePath = props.getString("lightProbPath", "");

       filesystem::path path = getFileResolver()->resolve(filePath);
        //try to set it
        try {
            if (path.extension() == "exr") {
                m_lightprobe = new Bitmap(path.str());
                m_wrapper = new HSWrapper(*m_lightprobe);
                m_latlngMap = new LatLongMap();
                m_BBox.min = Point2i(0, 0);
                m_BBox.max = Point2i(m_lightprobe->cols(), m_lightprobe->rows());
                m_width = m_lightprobe->cols();
                m_height = m_lightprobe->rows();
            } else {
                cerr << "Fatal error: unknown file \"" << filePath
                     << "\", expected an extension of type .exr" << endl;
            }
        } catch (const std::exception &e) {
            cerr << "Fatal error: " << e.what() << endl;
        }
    }

	HeterogeneousMedium(const PropertyList &propList) {
		// Denotes the scattering albedo
		m_albedo = propList.getColor("albedo");

		// An (optional) transformation that converts between medium and world coordinates
		m_worldToMedium = propList.getTransform("toWorld", Transform()).inverse();

		// Optional multiplicative factor that will be applied to all density values in the file
		m_densityMultiplier = propList.getFloat("densityMultiplier", 1.0f);

		m_filename = propList.getString("filename");
		QByteArray filename = m_filename.toLocal8Bit();
		QFile file(m_filename);

		if (!file.exists())
			throw NoriException(QString("The file \"%1\" does not exist!").arg(m_filename));

		/* Parse the file header */
		file.open(QIODevice::ReadOnly);
		QDataStream stream(&file);
		stream.setByteOrder(QDataStream::LittleEndian);

		qint8 header[3], version; qint32 type;
		stream >> header[0] >> header[1] >> header[2] >> version >> type;

		if (memcmp(header, "VOL", 3) != 0 || version != 3)
			throw NoriException("This is not a valid volume data file!");

		stream >> m_resolution.x() >> m_resolution.y() >> m_resolution.z();
		file.close();

		cout << "Mapping \"" << filename.data() << "\" (" << m_resolution.x()
			<< "x" << m_resolution.y() << "x" << m_resolution.z() << ") into memory .." << endl;

		m_fileSize = (size_t) file.size();
		#if defined(PLATFORM_LINUX) || defined(PLATFORM_MACOS)
			int fd = open(filename.data(), O_RDONLY);
			if (fd == -1)
				throw NoriException(QString("Could not open \"%1\"!").arg(m_filename));
			m_data = (float *) mmap(NULL, m_fileSize, PROT_READ, MAP_SHARED, fd, 0);
			if (m_data == NULL)
				throw NoriException("mmap(): failed.");
			if (close(fd) != 0)
				throw NoriException("close(): unable to close file descriptor!");
		#elif defined(PLATFORM_WINDOWS)
			m_file = CreateFileA(filename.data(), GENERIC_READ, 
				FILE_SHARE_READ, NULL, OPEN_EXISTING, 
				FILE_ATTRIBUTE_NORMAL, NULL);
			if (m_file == INVALID_HANDLE_VALUE)
				throw NoriException(QString("Could not open \"%1\"!").arg(m_filename));
			m_fileMapping = CreateFileMapping(m_file, NULL, PAGE_READONLY, 0, 0, NULL);
			if (m_fileMapping == NULL)
				throw NoriException("CreateFileMapping(): failed.");
			m_data = (float *) MapViewOfFile(m_fileMapping, FILE_MAP_READ, 0, 0, 0);
			if (m_data == NULL)
				throw NoriException("MapViewOfFile(): failed.");
		#endif

		m_data += 12; // Shift past the header
	}

    StudentsTTest(const PropertyList &propList) {
        /* The null hypothesis will be rejected when the associated
           p-value is below the significance level specified here. */
        m_significanceLevel = propList.getFloat("significanceLevel", 0.01f);

        /* This parameter specifies a list of incidence angles that will be tested */
        std::vector<std::string> angles = tokenize(propList.getString("angles", ""));
        for (auto angle : angles)
            m_angles.push_back(toFloat(angle));

        /* This parameter specifies a list of reference values, one for each angle */
        std::vector<std::string> references = tokenize(propList.getString("references", ""));
        for (auto angle : references)
            m_references.push_back(toFloat(angle));

        /* Number of BSDF samples that should be generated (default: 100K) */
        m_sampleCount = propList.getInteger("sampleCount", 100000);
    }

	Path(const PropertyList &propList) {
		m_maxDepth = propList.getInteger("maxDepth", 13);
		QString samplePolicy = propList.getString("samplePolicy", "SampleBoth");
		if (samplePolicy == "SampleBsdf") {
			m_samplePolicy = ESampleBsdf;
		} else if (samplePolicy == "sampleLight") {
			m_samplePolicy = ESampleLight;
		} else {
			m_samplePolicy = EMis;
		}
	}

    Conductor(const PropertyList &propList) {
        materialName = propList.getString("materialName", "");

        if(materialName != "") {
            // load the specific material properties
            if(!getMaterialProperties(materialName, m_eta, m_k)){
                std::cout << "Material " << materialName << " not found!" << std::endl;
            }
        } else {
            m_eta = propList.getColor("eta");
            m_k = propList.getColor("k");
        }
    }

    RoughConductor(const PropertyList &propList) {
        materialName = propList.getString("materialName", "");

        if(materialName != "") {
            // load the specific material properties
            if(!getMaterialProperties(materialName, m_eta, m_k)){
                std::cout << "Material " << materialName << " not found!" << std::endl;
            }
        } else {
            m_eta = propList.getColor("eta");
            m_k = propList.getColor("k");
        }

        /* RMS surface roughness */
        m_alpha = propList.getFloat("alpha", 0.1f);
    }

std::shared_ptr<Object> ObjectFactory :: create(std::string name, std::string type)
{
    // create an Object class as a prototype to open config file of above name
    std::unique_ptr<Object> prototype;

    if(!Filesystem::hasExtension(name))
        name += ".ini";
    
    // deduce type from ini
    if(type.empty())
    {
        // trying to deduce type of object without extension is impossible
        if(!Filesystem::hasExtension(name, "ini"))
        {
            assert(false);
            return std::shared_ptr<Object>();
        }

        PropertyList properties;
        boost::filesystem::path path = System::get().imageResources().locate(name);
        name = path.string();

        if(!properties.open(name.c_str()))
        {
            assert(false);
            return std::shared_ptr<Object>();
        }
        type = properties.getString("default", "type", "");
        if(type.empty())
        {
            assert(false);
            return std::shared_ptr<Object>();
        }
    }   

    //// locate an object
    //if(Filesystem::hasExtension("ini"))
    //{
    //    std::vector<boost::filesystem::path> search_paths;
    //    if(type == "backdrop")
    //        search_paths.push_back(boost::filesystem::path("data/backdrops/"));
    //    else
    //        search_paths.push_back(boost::filesystem::path("data/objects/"));
    //    std::vector<std::string> extensions;

    //    extensions.push_back("ini"); // load as image

    //    boost::filesystem::path found = Filesystem::locate(name, search_paths, extensions);
    //    if(found)
    //        name = found.string();
    //}

    // dispatch pattern by object type, return Object pointer
    try{
        std::shared_ptr<Object> object;
        // add more object types to this list
        if(type == "enemy")
            object.reset(new Enemy(name));
        else if(type == "particle")
            object.reset(new Particle(name));
        else if(type == "backdrop")
            object.reset(new Backdrop(name));
        else if(type == "item")
            object.reset(new Item(name));
        else
            return std::shared_ptr<Object>();

        if(object)
            m_pWorld->add(object);
        return object;
    } catch(const Failure& f){
        assert(false);
    }

    return std::shared_ptr<Object>();
}