示例#1
0
void ParticleEmitter::LoadFromYaml(const String & filename)
{
    Cleanup(true);

    YamlParser * parser = YamlParser::Create(filename);
    if(!parser)
    {
        Logger::Error("ParticleEmitter::LoadFromYaml failed (%s)", filename.c_str());
        return;
    }

    configPath = filename;
    time = 0.0f;
    repeatCount = 0;
    lifeTime = 1000000000.0f;

    YamlNode * rootNode = parser->GetRootNode();

    YamlNode * emitterNode = rootNode->Get("emitter");
    if (emitterNode)
    {
        if (emitterNode->Get("emissionAngle"))
            emissionAngle = PropertyLineYamlReader::CreateFloatPropertyLineFromYamlNode(emitterNode, "emissionAngle");

        if (emitterNode->Get("emissionVector"))
            emissionVector = PropertyLineYamlReader::CreateVector3PropertyLineFromYamlNode(emitterNode, "emissionVector");

        YamlNode* emissionVectorInvertedNode = emitterNode->Get("emissionVectorInverted");
        if (!emissionVectorInvertedNode)
        {
            // Yuri Coder, 2013/04/12. This means that the emission vector in the YAML file is not inverted yet.
            // Because of [DF-1003] fix for such files we have to invert coordinates for this vector.
            InvertEmissionVectorCoordinates();
        }

        if (emitterNode->Get("emissionRange"))
            emissionRange = PropertyLineYamlReader::CreateFloatPropertyLineFromYamlNode(emitterNode, "emissionRange");

        if (emitterNode->Get("colorOverLife"))
            colorOverLife = PropertyLineYamlReader::CreateColorPropertyLineFromYamlNode(emitterNode, "colorOverLife");
        if (emitterNode->Get("radius"))
            radius = PropertyLineYamlReader::CreateFloatPropertyLineFromYamlNode(emitterNode, "radius");

        emitPointsCount = -1;
        YamlNode * emitAtPointsNode = emitterNode->Get("emitAtPoints");
        if (emitAtPointsNode)
            emitPointsCount = emitAtPointsNode->AsInt();

        YamlNode * lifeTimeNode = emitterNode->Get("life");
        if (lifeTimeNode)
        {
            lifeTime = lifeTimeNode->AsFloat();
        } else
        {
            lifeTime = 1000000000.0f;
        }

        is3D = false;
        YamlNode * _3dNode = emitterNode->Get("3d");
        if (_3dNode)
        {
            is3D = _3dNode->AsBool();
        }

        YamlNode * typeNode = emitterNode->Get("type");
        if (typeNode)
        {
            if (typeNode->AsString() == "point")
                emitterType = EMITTER_POINT;
            else if (typeNode->AsString() == "line")
            {
                // Yuri Coder, 2013/04/09. Get rid of the "line" node type -
                // it can be completely replaced by "rect" one.
                emitterType = EMITTER_RECT;
            }
            else if (typeNode->AsString() == "rect")
                emitterType = EMITTER_RECT;
            else if (typeNode->AsString() == "oncircle")
                emitterType = EMITTER_ONCIRCLE;
            else if (typeNode->AsString() == "shockwave")
                emitterType = EMITTER_SHOCKWAVE;
            else
                emitterType = EMITTER_POINT;
        } else
            emitterType = EMITTER_POINT;

        size = PropertyLineYamlReader::CreateVector3PropertyLineFromYamlNode(emitterNode, "size");

        if(size == 0)
        {
            Vector3 _size(0, 0, 0);
            YamlNode * widthNode = emitterNode->Get("width");
            if (widthNode)
                _size.x = widthNode->AsFloat();

            YamlNode * heightNode = emitterNode->Get("height");
            if (heightNode)
                _size.y = heightNode->AsFloat();

            YamlNode * depthNode = emitterNode->Get("depth");
            if (depthNode)
                _size.y = depthNode->AsFloat();

            size = new PropertyLineValue<Vector3>(_size);
        }

        YamlNode * autorestartNode = emitterNode->Get("autorestart");
        if(autorestartNode)
            isAutorestart = autorestartNode->AsBool();

        YamlNode * particlesFollowNode = emitterNode->Get("particlesFollow");
        if(particlesFollowNode)
            particlesFollow = particlesFollowNode->AsBool();
    }

    int cnt = rootNode->GetCount();
    for (int k = 0; k < cnt; ++k)
    {
        YamlNode * node = rootNode->Get(k);
        YamlNode * typeNode = node->Get("type");

        YamlNode * longNode = node->Get("isLong");
        bool isLong = false;
        if(longNode && (longNode->AsBool() == true))
        {
            isLong = true;
        }

        if (typeNode && typeNode->AsString() == "layer")
        {
            LoadParticleLayerFromYaml(node, isLong);
        }
    }

    // Yuri Coder, 2013/01/15. The "name" node for Layer was just added and may not exist for
    // old yaml files. Generate the default name for nodes with empty names.
    UpdateEmptyLayerNames();

    SafeRelease(parser);
}
void EditorConfig::ParseConfig(const String &filePath)
{
	ClearConfig();

    YamlParser *parser = YamlParser::Create(filePath);
    if(parser)
    {
		YamlNode *rootNode = parser->GetRootNode();
		if(rootNode)
		{
			Vector<YamlNode*> &yamlNodes = rootNode->AsVector();
			int32 propertiesCount = yamlNodes.size();
			for(int32 i = 0; i < propertiesCount; ++i)
			{
				YamlNode *propertyNode = yamlNodes[i];
				if(propertyNode)
				{
					YamlNode *nameNode = propertyNode->Get("name");
					YamlNode *typeNode = propertyNode->Get("type");
					YamlNode *defaultNode = propertyNode->Get("default");
					if(nameNode && typeNode)
					{
						String nameStr = nameNode->AsString();
						String typeStr = typeNode->AsString();
						int32 type = ParseType(typeStr);
						if(type)
						{
							bool isOk = true;
							for(uint32 n = 0; n < propertyNames.size(); ++n)
							{
								if(propertyNames[n] == nameStr)
								{
									isOk = false;
									Logger::Error("EditorConfig::ParseConfig %s ERROR property %d property %s already exists", filePath.c_str(), i, nameStr.c_str());
									break;
								}
							}

							if(isOk)
							{
								properties[nameStr] = new PropertyDescription();
								properties[nameStr]->name = nameStr;
								properties[nameStr]->type = type;
								switch(type)
								{
								case PT_BOOL:
									{
										bool defaultValue = false;
										if(defaultNode)
										{
											defaultValue = defaultNode->AsBool();
										}
										properties[nameStr]->defaultValue.SetBool(defaultValue);
									}
									break;
								case PT_INT:
									{
										int32 defaultValue = 0;
										if(defaultNode)
										{
											defaultValue = defaultNode->AsInt();
										}
										properties[nameStr]->defaultValue.SetInt32(defaultValue);
									}
									break;
								case PT_STRING:
									{
										String defaultValue;
										if(defaultNode)
										{
											defaultValue = defaultNode->AsString();
										}
										properties[nameStr]->defaultValue.SetString(defaultValue);
									}
									break;
								case PT_FLOAT:
									{
										float32 defaultValue = 0.0f;
										if(defaultNode)
										{
											defaultValue = defaultNode->AsFloat();
										}
										properties[nameStr]->defaultValue.SetFloat(defaultValue);
									}
									break;
								case PT_COMBOBOX:
									{
										int32 defaultValue = 0;
										if(defaultNode)
										{
											defaultValue = defaultNode->AsInt();
										}
										properties[nameStr]->defaultValue.SetInt32(defaultValue);

										YamlNode *comboNode = propertyNode->Get("list");
										if(comboNode)
										{
											Vector<YamlNode*> comboValueNodes = comboNode->AsVector();
											int32 comboValuesCount = comboValueNodes.size();
											for(int32 i = 0; i < comboValuesCount; ++i)
											{
												properties[nameStr]->comboValues.push_back(comboValueNodes[i]->AsString());
											}
										}
									}
									break;
                                case PT_COLOR_LIST:
                                    {
                                        int32 defaultValue = 0;
                                        if(defaultNode)
                                        {
                                            defaultValue = defaultNode->AsInt();
                                        }
                                        properties[nameStr]->defaultValue.SetInt32(defaultValue);
                                        
                                        YamlNode *colorListNode = propertyNode->Get("list");
                                        if(colorListNode)
                                        {
                                            Vector<YamlNode*> colorListNodes = colorListNode->AsVector();
                                            int32 colorListValuesCount = colorListNodes.size();
                                            for(int32 i = 0; i < colorListValuesCount; ++i)
                                            {
                                                YamlNode* colorNode = colorListNodes[i];
                                                if(!colorNode || colorNode->GetCount() != 4)
                                                    continue;
                                                
                                                Color color(colorNode->Get(0)->AsFloat()/255.f,
                                                            colorNode->Get(1)->AsFloat()/255.f,
                                                            colorNode->Get(2)->AsFloat()/255.f,
                                                            colorNode->Get(3)->AsFloat()/255.f);

                                                properties[nameStr]->colorListValues.push_back(color);
                                            }
                                        }
                                    }
                                    break;
								}
								propertyNames.push_back(nameStr);
							} //isOk
						}
						else
						{
							Logger::Error("EditorConfig::ParseConfig %s ERROR property %d unknown type %s", filePath.c_str(), i, typeStr.c_str());
						}
					}
					else
					{
						Logger::Error("EditorConfig::ParseConfig %s ERROR property %d type or name is missing", filePath.c_str(), i);
					}
				}
				else
				{
					Logger::Error("EditorConfig::ParseConfig %s ERROR property %d is missing", filePath.c_str(), i);
				}
			}
		} 
		// else file is empty - ok, no custom properties

		parser->Release();
	}
	// else file not found - ok, no custom properties
}