C++ ofXml::getAttribute方法代码示例

void Render::loadXML(ofXml &xml) {
    if (xml.exists("[@vsync]")) {
        string str = ofToString( xml.getAttribute("[@vsync]") );
        if (str == "on")    vsync = true;
        else                vsync = false;
    }
    if (xml.exists("[@framerate]"))
        framerate = ofToInt( xml.getAttribute("[@framerate]") );
    setup();
}

void Socket::loadXML(ofXml &xml) {
    if (xml.exists("socket[@enabled]")) {
        string str = ofToString(xml.getAttribute("socket[@enabled]"));
        if (str == "on") enabled = true;
        else             enabled = false;
    }
    
    if (xml.exists("socket[@host]"))
        host = ofToString( xml.getAttribute("socket[@host]") );
    if (xml.exists("socket[@send]"))
        send = ofToInt( xml.getAttribute("socket[@send]") );
    if (xml.exists("socket[@receive]"))
        receive = ofToInt( xml.getAttribute("socket[@receive]") );
    
    if (enabled)
        setup();
}

void Projector::loadXML(ofXml &xml) {
    string str;
    
    if (xml.exists("[@resolution]")) {
        str = xml.getAttribute("[@resolution]");
        width = ofToFloat(ofSplitString(str, ",")[0]);
        height = ofToFloat(ofSplitString(str, ",")[1]);
    }
}

void Projector::loadXML2(ofXml &xml) {
    string str;
    float val;

    // color
    if (xml.exists("[@brightness]")) {
        brightness = ofToFloat( xml.getAttribute("[@brightness]"));
    }
    if (xml.exists("[@contrast]")) {
        contrast = ofToFloat( xml.getAttribute("[@contrast]") );
    }
    if (xml.exists("[@saturation]")) {
        saturation = ofToFloat( xml.getAttribute("[@saturation]") );
    }

    // plane warp
    plane.width = width;
    plane.height = height;
    plane.load(xml, projectorStartingIndex);


    // camera position
    if (xml.exists("[@position]")) {
        str = xml.getAttribute("[@position]");
        float azi  = ofToFloat(ofSplitString(str, ",")[0]);
        float ele  = ofToFloat(ofSplitString(str, ",")[1]);
        float dis  = ofToFloat(ofSplitString(str, ",")[2]);
        setCameraPosition(azi, ele, dis);
    }

    // camera orientation
    if (xml.exists("[@orientation]")) {
        str = xml.getAttribute("[@orientation]");
        float roll = ofToFloat(ofSplitString(str, ",")[0]);
        float tilt = ofToFloat(ofSplitString(str, ",")[1]);
        float pan = ofToFloat(ofSplitString(str, ",")[2]);
        setCameraOrientation(roll, tilt, pan);
    }

    // camera lens fov
    if (xml.exists("[@fov]")) {
        val = ofToFloat( xml.getAttribute("[@fov]") );
        setCameraFov(val);
    }

    //camera lens offset
    if (xml.exists("[@offset]")) {
        str = xml.getAttribute("[@offset]");
        float offX  = ofToFloat(ofSplitString(str, ",")[0]);
        float offY  = ofToFloat(ofSplitString(str, ",")[1]);
        setCameraOffset(offX, offY);
    }

	curves.load(projectorStartingIndex);

    mask.width = width;
    mask.height = height;
    mask.load(projectorStartingIndex);
}

void ofxShaderGraph::buildFromXml(ofXml x){
    unordered_set<string> root_names;

    x.reset();
    unsigned long n = x.getNumChildren();

    params.setName(x.getName());

    //first pass, create all nodes and set defaults
    for(unsigned long i=0; i<n; i++){
        x.reset();
        x.setToChild(i);
        if(x.getName()!="node")
            continue;
        string name = x.getAttribute("name");
        if(name==""){
            cout<<"ofxShaderGraph warning: anonymous node in XML"<<endl;
            continue;
        }
        ofxBaseShaderNode *node;
        ofFbo::Settings node_fbo_settings = fbo_settings;
        //check for modifications to fbo_settings
        if(x.setTo("scale")){
            float scale = x.getFloatValue();
            node_fbo_settings.width*=scale;
            node_fbo_settings.height*=scale;
            x.setToParent();
        }
        string format = x.getAttribute("format");
        if(format!=""){
            if(format=="rgba8")
                node_fbo_settings.internalformat = GL_RGBA8;
            else if(format=="rgba16")
                node_fbo_settings.internalformat = GL_RGBA16;
            else if(format=="rgba32f")
                node_fbo_settings.internalformat = GL_RGBA32F;
            else if(format=="rgba16f")
                node_fbo_settings.internalformat = GL_RGBA16F;
            else if(format=="rgb8")
                node_fbo_settings.internalformat = GL_RGB8;
            else if(format=="rgb16")
                node_fbo_settings.internalformat = GL_RGB16;
            else if(format=="rgb32f")
                node_fbo_settings.internalformat = GL_RGB32F;
            else if(format=="rgb16f")
                node_fbo_settings.internalformat = GL_RGB16F;
        }
        //check for node to swap buffers with
        string swap_name = x.getAttribute("swap");
        if(swap_name != ""){
            //don't duplicate pairs
            if(swap.count(swap_name)==0){
                cout<<"ofxShaderGraph: "<<name<<" swaps with "<<swap_name<<endl;
                swap.insert(pair<string, string>(name, swap_name));
            }else{
                cout<<"ofxShaderGraph warning: ignoring duplicate swap of"<<name<<" with "<<swap_name<<endl;
            }
        }
        //check for color to init buffer to
        if(x.setTo("init")){
            float val = x.getFloatValue();
            init.insert(pair<string, float>(name, val));
            x.setToParent();
        }
        //check for shader path
        string shader_name = x.getAttribute("shader");
        if(shader_name == ""){
            //shaderless node
            node = new ofxConstantShaderNode(allocator, node_fbo_settings, name);
        }
        else{
            ofShader *shader = new ofShader();
            stringstream shader_path;
            shader_path<<ofToDataPath("../../src/shader/")<<shader_name;
            shader->load(shader_path.str());
            if(!shader->isLoaded()){
                cout<<"ofxShaderGraph warning: shader "<<shader_name<<" failed to load from path "<<shader_path.str()<<endl;
            }
            else{
                cout<<"ofxShaderGraph: loaded shader "<<shader_name<<endl;
            }
            node = new ofxBaseShaderNode(allocator, node_fbo_settings, name, shader);
        }
        //grab all of the new node's parameters
        params.add(node->getParameterGroup());
        //put it in the map from names to nodes
        nodes.insert(pair<string, ofxBaseShaderNode*>(name, node));
        //everything goes in root_names, to be removed when is appears as an input
        root_names.insert(name);

        cout<<"ofxShaderGraph: inserted node "<<name<<endl;

        //set defaults
        if(x.setTo("defaults") && x.setToChild(0)){
            do{
                string param_type = x.getName();
                string param_name = x.getAttribute("name");
                if(param_type=="float"){
                    float v = x.getFloatValue();
                    node->setParameter(param_name, v);
//.........这里部分代码省略.........