void ShaderEditor::load()
{
	char path[Lumix::MAX_PATH_LENGTH];
	if (!PlatformInterface::getOpenFilename(path, Lumix::lengthOf(path), "Shader edit data\0*.sed\0", nullptr))
	{
		return;
	}
	m_path = path;

	clear();

	FILE* fp = fopen(path, "rb");
	if (!fp)
	{
		Lumix::g_log_error.log("Editor") << "Failed to load shader " << path;
		return;
	}

	fseek(fp, 0, SEEK_END);
	int data_size = (int)ftell(fp);
	Lumix::Array<Lumix::uint8> data(m_allocator);
	data.resize(data_size);
	fseek(fp, 0, SEEK_SET);
	fread(&data[0], 1, data_size, fp);

	Lumix::InputBlob blob(&data[0], data_size);
	for (int i = 0; i < Lumix::lengthOf(m_textures); ++i)
	{
		blob.readString(m_textures[i], Lumix::lengthOf(m_textures[i]));
	}

	int size;
	blob.read(size);
	for(int i = 0; i < size; ++i)
	{
		loadNode(blob, ShaderType::VERTEX);
	}

	for(auto* node : m_vertex_nodes)
	{
		loadNodeConnections(blob, *node);
		m_last_node_id = Lumix::Math::maxValue(int(node->m_id + 1), int(m_last_node_id));
	}

	blob.read(size);
	for (int i = 0; i < size; ++i)
	{
		loadNode(blob, ShaderType::FRAGMENT);
	}

	for (auto* node : m_fragment_nodes)
	{
		loadNodeConnections(blob, *node);
		m_last_node_id = Lumix::Math::maxValue(int(node->m_id + 1), int(m_last_node_id));
	}

	fclose(fp);
}
示例#2
0
void QTodoList::loadNode(QTodoNode* node, unsigned int depth)
{
	if(!node)
		return;

	for(QTodoNode::iterator it = node->begin(); it != node->end(); ++it)
	{
		if((*it)->section == true)
		{
			QTodoListViewItemSection* lists_item = new QTodoListViewItemSection(getTodoListWidget()->getListViewItem());
			QTodoSectionWidget* section = new QTodoSectionWidget(vbox,lists_item);
			lists_item->setSection(section);
			section->setName((*it)->task);
			section->show();
			continue;
		}

		QTodoItem* item = new QTodoItem(vbox);
		insertTodoAtBottom(item);

		item->setDepth(depth);
		item->setTask((*it)->task);
		item->setPriority((*it)->priority);
		item->setDeadline((*it)->deadline);
		item->setCreated((*it)->created);
		item->setDone((*it)->done);
		item->setStatus((*it)->status);
		item->setAgent((*it)->agent);
		item->show();
		loadNode((*it)->sub,depth+1);
	}
}
示例#3
0
AnimNode::Pointer AnimNodeLoader::load(const QByteArray& contents, const QUrl& jsonUrl) {

    // convert string into a json doc
    QJsonParseError error;
    auto doc = QJsonDocument::fromJson(contents, &error);
    if (error.error != QJsonParseError::NoError) {
        qCCritical(animation) << "AnimNodeLoader, failed to parse json, error =" << error.errorString();
        return nullptr;
    }
    QJsonObject obj = doc.object();

    // version
    QJsonValue versionVal = obj.value("version");
    if (!versionVal.isString()) {
        qCCritical(animation) << "AnimNodeLoader, bad string \"version\"";
        return nullptr;
    }
    QString version = versionVal.toString();

    // check version
    // AJT: TODO version check
    if (version != "1.0" && version != "1.1") {
        qCCritical(animation) << "AnimNodeLoader, bad version number" << version << "expected \"1.0\"";
        return nullptr;
    }

    // root
    QJsonValue rootVal = obj.value("root");
    if (!rootVal.isObject()) {
        qCCritical(animation) << "AnimNodeLoader, bad object \"root\"";
        return nullptr;
    }

    return loadNode(rootVal.toObject(), jsonUrl);
}
示例#4
0
void QTodoList::load(QTodoTopNode* top_node)
{
	loadNode(top_node->top,0);

	show();
	refreshSpacer();
}
    /*!
     * See \ref Loader3ds::loadFromFile
     */
    dcollide::Proxy* Loader3dsInternal::loadFromFile(dcollide::World* world, const char* fileName, dcollide::ProxyTypes proxyType) {
        mData->mProxy2Transformation.clear();
        mData->mProxy2TextureInformation.clear();
        if (!fileName) {
            // TODO: exception?
            return 0;
        }

        mFile = lib3ds_file_load(fileName);
        if (!mFile) {
            std::cout << dc_funcinfo << "unable to load " << fileName << std::endl;
            return 0;
        }

        // AB: some files don't store nodes and just want exactly one node per mesh.
        //     atm we don't support that.
        if (!mFile->nodes) {
            std::cout << dc_funcinfo << "File " << fileName << " does not contain any nodes. mesh-only files not supported currently." << std::endl;
            lib3ds_file_free(mFile);
            mFile = 0;
            return 0;
        }

        // 3ds stores several frames, we want the first
        lib3ds_file_eval(mFile, 0);

        if (!checkUniqueMeshMaterial()) {
            std::cerr << dc_funcinfo << "the file " << fileName << " contains at least one mesh with different materials. this is not supported by this modelloader, only the first material will be used!" << std::endl;
        }

        dcollide::Proxy* topObject = world->createProxy(proxyType);
        mData->mProxy2Transformation.insert(std::make_pair(topObject, Loader3ds::TransformationNode()));

        Lib3dsMatrix identityMatrix;
        lib3ds_matrix_identity(identityMatrix);
        Lib3dsNode* node = mFile->nodes;
        while (node) {
            // node->type can be object, light, camera, ...
            // -> only object nodes are relevant to us
            if (node->type == LIB3DS_OBJECT_NODE) {
                if (!loadNode(world, topObject, node, &identityMatrix)) {
                    std::cerr << dc_funcinfo << "Loading node from " << fileName << " failed" << std::endl;
                    // TODO: is MyObjectNode::mProxy being deleted?
                    delete topObject;
                    lib3ds_file_free(mFile);
                    mFile = 0;
                    return 0;
                }
            }

            node = node->next;
        }

        lib3ds_file_free(mFile);
        mFile = 0;
        return topObject;
    }
示例#6
0
Node* SystemClipboard::loadSubNode(Node* parent, const QString& name)
{
	if (!xml->hasChild(name)) return nullptr;

	xml->beginLoadChildNode(name);
	LoadedNode ln = loadNode(parent);
	xml->endLoadChildNode();

	return ln.node;
}
void NodeInstanceView::nodeCreated(const ModelNode &createdNode)
{
    NodeInstance instance = loadNode(createdNode);

    if (isSkippedNode(createdNode))
        return;

    nodeInstanceServer()->createInstances(createCreateInstancesCommand(QList<NodeInstance>() << instance));
    nodeInstanceServer()->changePropertyValues(createChangeValueCommand(createdNode.variantProperties()));
    nodeInstanceServer()->completeComponent(createComponentCompleteCommand(QList<NodeInstance>() << instance));
}
示例#8
0
bool Root::loadFrom(std::string name) {
    auto xml =
        Kriti::ResourceRegistry::get<Kriti::XMLResource>("conv/" + name);

    if(!xml) return false;

    auto objects = xml->doc().first_element_by_path("/conversation/objects");

    // First pass to create objects.
    for(auto c = objects.first_child(); c ; c = c.next_sibling()) {
        int id = c.attribute("id").as_int();
        if(!std::strcmp(c.name(), "node")) {
            m_nodeMap[id] = boost::make_shared<Node>();
        }
        else if(!std::strcmp(c.name(), "context")) {
            m_contextMap[id] = boost::make_shared<Context>();
        }
        else if(!std::strcmp(c.name(), "link")) {
            m_linkMap[id] = boost::make_shared<Link>();
        }
        else {
            Message3(Game, Debug, "Unknown object type " << c.name());
        }
    }

    // Second pass to parse objects.
    for(auto c = objects.first_child(); c ; c = c.next_sibling()) {
        int id = c.attribute("id").as_int();
        if(!std::strcmp(c.name(), "node")) {
            loadNode(id, c);
        }
        else if(!std::strcmp(c.name(), "context")) {
            loadContext(id, c);
        }
        else if(!std::strcmp(c.name(), "link")) {
            loadLink(id, c);
        }
        else {
            Message3(Game, Debug, "Unknown object type " << c.name());
        }
    }

    if(!m_rootNode) {
        Message3(Game, Error, "Couldn't load conversation \"" << name
            << "\": no root node");
        return false;
    }

    return true;
}
示例#9
0
//----------------------------------------------------------------------------------------------------------------------
void FileList::loadStructure(std::ifstream &_fname)
{
  std::string read;

      while(!_fname.eof() )
      {
          _fname>>read;

          if(trim(read) == "ROOT")
          {
              _fname>>read;
              loadNode(_fname);
          }

       }
示例#10
0
void NodeInstanceView::nodeCreated(const ModelNode &createdNode)
{
    NodeInstance instance = loadNode(createdNode);

    if (isSkippedNode(createdNode))
        return;

    QList<VariantProperty> propertyList;
    propertyList.append(createdNode.variantProperty("x"));
    propertyList.append(createdNode.variantProperty("y"));
    updatePosition(propertyList);

    nodeInstanceServer()->createInstances(createCreateInstancesCommand(QList<NodeInstance>() << instance));
    nodeInstanceServer()->changePropertyValues(createChangeValueCommand(createdNode.variantProperties()));
    nodeInstanceServer()->completeComponent(createComponentCompleteCommand(QList<NodeInstance>() << instance));
}
示例#11
0
void Ambient::playCurrentNode(uint32 volume, uint32 fadeOutDelay) {
	if (!fadeOutDelay) fadeOutDelay = 1;

	uint32 node = _vm->_state->getLocationNode();
	uint32 room = _vm->_state->getLocationRoom();
	uint32 age = _vm->_state->getLocationAge();

	// Load sound descriptors
	loadNode(node, room, age);

	// Adjust volume
	scaleVolume(volume);

	// Play sounds
	applySounds(fadeOutDelay);
}
    /*!
     * \internal
     *
     * The objects created as children of \p parent will \em not be rotated or
     * translated correctly. Instead the required transformations are stored and
     * provided to the user, see \ref Loader3ds::getTransformationNodes
     */
    bool Loader3dsInternal::loadNode(dcollide::World* world, dcollide::Proxy* parent, Lib3dsNode* node, Lib3dsMatrix* parentTranslateRotateMatrix) {
        if (!parent || !node) {
            return false;
        }
        if (node->type != LIB3DS_OBJECT_NODE) {
            return false;
        }
        Lib3dsObjectData* data = &node->data.object;

        Lib3dsMatrix translateRotateMatrix;
        lib3ds_matrix_copy(translateRotateMatrix, *parentTranslateRotateMatrix);
        lib3ds_matrix_translate(translateRotateMatrix, data->pos);
        lib3ds_matrix_rotate(translateRotateMatrix, data->rot);

        dcollide::Shape* shape = createShape(node, &translateRotateMatrix);
        dcollide::Proxy* object = world->createProxy(shape);

        mData->mProxy2TextureInformation.insert(std::make_pair(object, loadTextureInformation(node)));

        dcollide::Vector3 scale(data->scl[0], data->scl[1], data->scl[2]);
        dcollide::Vector3 translation(data->pos[0], data->pos[1], data->pos[2]);

        Lib3dsMatrix lib3dsRotationMatrix;
        lib3ds_matrix_identity(lib3dsRotationMatrix);
        lib3ds_matrix_rotate(lib3dsRotationMatrix, data->rot);
        dcollide::Matrix rotation(&lib3dsRotationMatrix[0][0]);

        Loader3ds::TransformationNode transformation;
        transformation.translation = translation;
        transformation.rotation = rotation;

        mData->mProxy2Transformation.insert(std::make_pair(object, transformation));

        for (Lib3dsNode* n = node->childs; n; n = n->next) {
            if (!loadNode(world, object, n, &translateRotateMatrix)) {
                std::cerr << "Failed loading node " << n->name << std::endl;
                // TODO: delete object->getProxy() ?
                delete object;
                return false;
            }
        }

        parent->addChild(object);

        return true;
    }
示例#13
0
QList<LoadedNode> SystemClipboard::loadAllSubNodes(Node* parent)
{
	QList<LoadedNode> result;

	if ( xml->hasChildren() )
	{
		xml->goToFirstChild();
		while ( true )
		{
			LoadedNode ln = loadNode(parent);
			result.append(ln);
			if ( xml->hasNext() ) xml->loadNext();
			else break;
		}
		xml->goToParent();
	}

	return result;
}
  CoronaLoader::CoronaLoader(const FileName& fileName, const AffineSpace3fa& space)
  {
    path = fileName.path();
    Ref<XML> xml = parseXML(fileName,"/.-",false);
    if (xml->name == "scene") 
    {
      Ref<SceneGraph::GroupNode> group = new SceneGraph::GroupNode;
      for (size_t i=0; i<xml->children.size(); i++) { 
        group->add(loadNode(xml->children[i]));
      }
      root = group.cast<SceneGraph::Node>();
    }
    else 
      THROW_RUNTIME_ERROR(xml->loc.str()+": invalid scene tag");

    if (space == AffineSpace3fa(one)) 
      return;
    
    root = new SceneGraph::TransformNode(space,root);
  }
示例#15
0
NodePtr LazyGraph::getNode(NodeId id)
{
    if (id.id == NULL_ID) {
        return NULL;
    }

    map<NodeId, Node *>::iterator i = nodes.find(id);
    if (i != nodes.end()) { // if the requested resource has already been loaded
        NodePtr r = i->second;
        nodeCache->remove(r);// we remove it from the unusedResources Cache
        //r->owner = this;
        // and we return the resource
        return r;
    }
    if (Logger::DEBUG_LOGGER != NULL) {
        ostringstream os;
        os << "Loading node '" << id.id << "'";
        Logger::DEBUG_LOGGER->log("GRAPH", os.str());
    }
    // otherwise the resource is not already loaded; we first load its descriptor
    NodePtr r = NULL;
    long int offset;
    map<NodeId, long int>::iterator j = nodeOffsets.find(id);
    if (j != nodeOffsets.end()) {
        offset = j->second;
        r = loadNode(offset, id);
        nodes[id] = r.get();
        mapping->insert(make_pair(r->getPos(), r.get()));
        return r;
    }

    if (Logger::ERROR_LOGGER != NULL) {
        ostringstream os;
        os << "Loading : Missing or invalid node '" << id.id << "'";
        Logger::ERROR_LOGGER->log("GRAPH", os.str());
    }
    throw exception();
//    return NULL;
}
示例#16
0
void xmlLoader::loadReaction(reaction &r, ofxXmlSettings &XML) {

    r.rType = XML.getValue("TYPE", "closeOutZone");
    r.trig = XML.getValue("TRIG", "ON");
    if(XML.tagExists("PRESET"))r.stringParams["PRESET"] = XML.getValue("PRESET","default");
    if(XML.tagExists("P_CHILD")){
        clamourNode temp = presetStore::nodePresets[XML.getValue("P_CHILD","defaultNode")];
        loadNode(temp, XML);
        r.tempNode = ofPtr<clamourNode>(new clamourNode(temp));
    }

    if(XML.tagExists("SCALE"))r.floatParams["SCALE"] = XML.getValue("SCALE", 1.0);
    if(XML.tagExists("ENV_INDEX"))r.intParams["ENV_INDEX"] = XML.getValue("ENV_INDEX", 1);
    if(XML.tagExists("DELAY_SECS"))r.floatParams["DELAY_SECS"] = XML.getValue("DELAY_SECS", 0.25);
    if(XML.tagExists("NAME"))r.stringParams["NAME"] = XML.getValue("NAME", "");


    int numZs = XML.getNumTags("Z_TARGET");

    for(int i = 0; i < numZs; i++){
        r.zTargets.push_back(XML.getValue("Z_TARGET", "",i));
    }

}
/*! \brief Notifing the view that a node was created.
  A NodeInstance will be created for the new created ModelNode.
\param createdNode New created ModelNode.
*/
void NodeInstanceView::nodeCreated(const ModelNode &createdNode)
{
    loadNode(createdNode);
}
示例#18
0
static AnimNode::Pointer loadNode(const QJsonObject& jsonObj, const QUrl& jsonUrl) {
    auto idVal = jsonObj.value("id");
    if (!idVal.isString()) {
        qCCritical(animation) << "AnimNodeLoader, bad string \"id\"";
        return nullptr;
    }
    QString id = idVal.toString();

    auto typeVal = jsonObj.value("type");
    if (!typeVal.isString()) {
        qCCritical(animation) << "AnimNodeLoader, bad object \"type\", id =" << id;
        return nullptr;
    }
    QString typeStr = typeVal.toString();
    AnimNode::Type type = stringToAnimNodeType(typeStr);
    if (type == AnimNode::Type::NumTypes) {
        qCCritical(animation) << "AnimNodeLoader, unknown node type" << typeStr << ", id =" << id;
        return nullptr;
    }

    auto dataValue = jsonObj.value("data");
    if (!dataValue.isObject()) {
        qCCritical(animation) << "AnimNodeLoader, bad string \"data\", id =" << id;
        return nullptr;
    }
    auto dataObj = dataValue.toObject();

    std::vector<QString> outputJoints;

    auto outputJoints_VAL = dataObj.value("outputJoints");
    if (outputJoints_VAL.isArray()) {
        QJsonArray outputJoints_ARRAY = outputJoints_VAL.toArray();
        for (int i = 0; i < outputJoints_ARRAY.size(); i++) {
            outputJoints.push_back(outputJoints_ARRAY.at(i).toString());
        }
    }

    assert((int)type >= 0 && type < AnimNode::Type::NumTypes);
    auto node = (animNodeTypeToLoaderFunc(type))(dataObj, id, jsonUrl);
    if (!node) {
        return nullptr;
    }

    auto childrenValue = jsonObj.value("children");
    if (!childrenValue.isArray()) {
        qCCritical(animation) << "AnimNodeLoader, bad array \"children\", id =" << id;
        return nullptr;
    }
    auto childrenArray = childrenValue.toArray();
    for (const auto& childValue : childrenArray) {
        if (!childValue.isObject()) {
            qCCritical(animation) << "AnimNodeLoader, bad object in \"children\", id =" << id;
            return nullptr;
        }
        AnimNode::Pointer child = loadNode(childValue.toObject(), jsonUrl);
        if (child) {
            node->addChild(child);
        } else {
            return nullptr;
        }
    }

    if ((animNodeTypeToProcessFunc(type))(node, dataObj, id, jsonUrl)) {
        for (auto&& outputJoint : outputJoints) {
            node->addOutputJoint(outputJoint);
        }
        return node;
    } else {
        return nullptr;
    }
}