예제 #1
0
bool EffectParser::Parse(OverlayRenderer* renderer, vector<TextureRender*> *renderElms, std::string file, Json::Value data) {
    filebuf fb;
    fb.open (file,ios::in);
    istream is(&fb);

    if(!fb.is_open()){
        FLog::Log(FLOG_ERROR, "EffectParser::Parse - Failed to load script file.");
        return false;
    }

    Json::Value root;
    Json::Reader reader;
    bool parsedSuccess = reader.parse(is, root, false);
    fb.close();
    if(!parsedSuccess){
        FLog::Log(FLOG_ERROR, "EffectParser::Parse - Failed to parse script json.");
        return false;
    }

     //check type exists
    if(!root.isMember("effects")){
        FLog::Log(FLOG_ERROR, "EffectParser::Parse - No list of effects");
        return false;
    }

    Json::Value e = root["effects"];

    for(Json::ValueIterator it = e.begin(); it != e.end(); it++){
        TextureRender *ren = ParseEffect(renderer, *it, &data);
        if(ren != NULL)
            renderElms->push_back(ren);
    }

    return true;
}
예제 #2
0
std::shared_ptr<Spell> SpellParser::Parse(LPCTSTR pszText)
{
   m_tokenizer = StringTokenizer(pszText);

   unsigned int uiSpellId = ParseUint(m_tokenizer.Next());
   unsigned int uiCooldown = 0;
   unsigned int uiCastTime = 0;
   bool bStackable = false;
   unsigned int uiRange = 0;
   bool bArea = false;
   std::vector<std::shared_ptr<SpellEffect>> vecEffects;

   CString cszToken;
   while (!m_tokenizer.IsEmpty())
   {
      cszToken = m_tokenizer.Next();

      if (cszToken == _T("cooldown"))
      {
         uiCooldown = TimeToSeconds(m_tokenizer.Next());
      }
      else
      if (cszToken == _T("cast-time"))
      {
         uiCastTime = TimeToSeconds(m_tokenizer.Next());
      }
      else
      if (cszToken == _T("stackable"))
      {
         bStackable = true;
      }
      else
      if (cszToken == _T("range"))
      {
         uiRange = ParseUint(m_tokenizer.Next());
      }
      else
      if (cszToken == _T("area"))
      {
         bArea = true;
      }
      else
      if (cszToken == _T("effect"))
      {
         ATLVERIFY(_T("[") == m_tokenizer.Next());
         vecEffects.push_back(ParseEffect());
      }
   }

   if (vecEffects.empty())
      throw Exception(_T("error parsing spell: no effect specified"), __FILE__, __LINE__);

   std::shared_ptr<Spell> spSpell(new Spell(uiSpellId, vecEffects[0]));

   spSpell->Cooldown(uiCooldown);
   spSpell->CastTime(uiCastTime);
   spSpell->Stackable(bStackable);
   spSpell->Range(uiRange);
   spSpell->AreaSpell(bArea);

   if (vecEffects.size() > 2)
      throw Exception(_T("error parsing spell: too many effects specified"), __FILE__, __LINE__);

   if (vecEffects.size() == 2)
      spSpell->Effect2(vecEffects[1]);

   return spSpell;
}
예제 #3
0
/*!***************************************************************************
 @Function			Parse
 @Output			pReturnError	error string
 @Return			bool			true for success parsing file
 @Description		Parses a loaded PFX file.
*****************************************************************************/
bool CPVRTPFXParser::Parse(CPVRTString * const pReturnError)
{
	int nEndLine = 0;
	int nHeaderCounter = 0, nTexturesCounter = 0;
	unsigned int i,j,k;
	m_nNumVertShaders	= 0;
	m_nNumFragShaders	= 0;
	m_nNumEffects		= 0;

	// Loop through the file
	for(unsigned int nLine=0; nLine < m_psContext->nNumLines; nLine++)
	{
		// Skip blank lines
		if(!*m_psContext->ppszEffectFile[nLine])
			continue;

		if(strcmp("[HEADER]", m_psContext->ppszEffectFile[nLine]) == 0)
		{
			if(nHeaderCounter>0)
			{
				sprintf(errorMsg, "[HEADER] redefined on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			if(GetEndTag("HEADER", nLine, &nEndLine))
			{
				if(ParseHeader(nLine, nEndLine, pReturnError))
					nHeaderCounter++;
				else
					return false;
			}
			else
			{
				sprintf(errorMsg, "Missing [/HEADER] tag after [HEADER] on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			nLine = nEndLine;
		}
		else if(strcmp("[TEXTURES]", m_psContext->ppszEffectFile[nLine]) == 0)
		{
			if(nTexturesCounter>0)
			{
				sprintf(errorMsg, "[TEXTURES] redefined on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			if(GetEndTag("TEXTURES", nLine, &nEndLine))
			{
				if(ParseTextures(nLine, nEndLine, pReturnError))
					nTexturesCounter++;
				else
					return false;
			}
			else
			{
				sprintf(errorMsg, "Missing [/TEXTURES] tag after [TEXTURES] on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			nLine = nEndLine;
		}
		else if(strcmp("[VERTEXSHADER]", m_psContext->ppszEffectFile[nLine]) == 0)
		{
			if(GetEndTag("VERTEXSHADER", nLine, &nEndLine))
			{
				if(m_nNumVertShaders >= m_nMaxVertShaders)
				{
					sprintf(errorMsg, "%d vertex shaders read, can't store any more, on line %d\n", m_nNumVertShaders, m_psContext->pnFileLineNumber[nLine]);
					*pReturnError = errorMsg;
					return false;
				}
				if(ParseShader(nLine, nEndLine, pReturnError, m_psVertexShader[m_nNumVertShaders], "VERTEXSHADER"))
					m_nNumVertShaders++;
				else
				{
					FREE(m_psVertexShader[m_nNumVertShaders].pszName);
					FREE(m_psVertexShader[m_nNumVertShaders].pszGLSLfile);
					FREE(m_psVertexShader[m_nNumVertShaders].pszGLSLcode);
					FREE(m_psVertexShader[m_nNumVertShaders].pszGLSLBinaryFile);
					return false;
				}
			}
			else
			{
				sprintf(errorMsg, "Missing [/VERTEXSHADER] tag after [VERTEXSHADER] on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			nLine = nEndLine;
		}
		else if(strcmp("[FRAGMENTSHADER]", m_psContext->ppszEffectFile[nLine]) == 0)
		{
			if(GetEndTag("FRAGMENTSHADER", nLine, &nEndLine))
			{
				if(m_nNumFragShaders >= m_nMaxFragShaders)
				{
					sprintf(errorMsg, "%d fragment shaders read, can't store any more, on line %d\n", m_nNumFragShaders, m_psContext->pnFileLineNumber[nLine]);
					*pReturnError = errorMsg;
					return false;
				}
				if(ParseShader(nLine, nEndLine, pReturnError, m_psFragmentShader[m_nNumFragShaders], "FRAGMENTSHADER"))
					m_nNumFragShaders++;
				else
				{
					FREE(m_psFragmentShader[m_nNumFragShaders].pszName);
					FREE(m_psFragmentShader[m_nNumFragShaders].pszGLSLfile);
					FREE(m_psFragmentShader[m_nNumFragShaders].pszGLSLcode);
					FREE(m_psFragmentShader[m_nNumFragShaders].pszGLSLBinaryFile);
					return false;
				}
			}
			else
			{
				sprintf(errorMsg, "Missing [/FRAGMENTSHADER] tag after [FRAGMENTSHADER] on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			nLine = nEndLine;
		}
		else if(strcmp("[EFFECT]", m_psContext->ppszEffectFile[nLine]) == 0)
		{
			if(GetEndTag("EFFECT", nLine, &nEndLine))
			{
				if(m_nNumEffects >= m_nMaxEffects)
				{
					sprintf(errorMsg, "%d effects read, can't store any more, on line %d\n", m_nNumEffects, m_psContext->pnFileLineNumber[nLine]);
					*pReturnError = errorMsg;
					return false;
				}
				if(ParseEffect(m_psEffect[m_nNumEffects], nLine, nEndLine, pReturnError))
					m_nNumEffects++;
				else
				{
					for(i=0; i < m_psEffect[m_nNumEffects].nNumUniforms; ++i)
					{
						FREE(m_psEffect[m_nNumEffects].psUniform[i].pszName);
						FREE(m_psEffect[m_nNumEffects].psUniform[i].pszValue);
					}
					delete [] m_psEffect[m_nNumEffects].psUniform;

					for(i=0; i < m_psEffect[m_nNumEffects].nNumAttributes; ++i)
					{
						FREE(m_psEffect[m_nNumEffects].psAttribute[i].pszName);
						FREE(m_psEffect[m_nNumEffects].psAttribute[i].pszValue);
					}
					delete [] m_psEffect[m_nNumEffects].psAttribute;

					for(i=0; i < m_psEffect[m_nNumEffects].nNumTextures; ++i)
					{
						FREE(m_psEffect[m_nNumEffects].psTextures[i].pszName);
					}
					delete [] m_psEffect[m_nNumEffects].psTextures;

					FREE(m_psEffect[m_nNumEffects].pszFragmentShaderName);
					FREE(m_psEffect[m_nNumEffects].pszVertexShaderName);

					FREE(m_psEffect[m_nNumEffects].pszAnnotation);
					FREE(m_psEffect[m_nNumEffects].pszName);

					return false;
				}
			}
			else
			{
				sprintf(errorMsg, "Missing [/EFFECT] tag after [EFFECT] on line %d\n", m_psContext->pnFileLineNumber[nLine]);
				*pReturnError = errorMsg;
				return false;
			}
			nLine = nEndLine;
		}
		else
		{
			sprintf(errorMsg, "'%s' unexpected on line %d\n", m_psContext->ppszEffectFile[nLine], m_psContext->pnFileLineNumber[nLine]);
			*pReturnError = errorMsg;
			return false;
		}
	}

	if(m_nNumEffects < 1)
	{
		sprintf(errorMsg, "No [EFFECT] found. PFX file must have at least one defined.\n");
		*pReturnError = errorMsg;
		return false;
	}

	if(m_nNumFragShaders < 1)
	{
		sprintf(errorMsg, "No [FRAGMENTSHADER] found. PFX file must have at least one defined.\n");
		*pReturnError = errorMsg;
		return false;
	}

	if(m_nNumVertShaders < 1)
	{
		sprintf(errorMsg, "No [VERTEXSHADER] found. PFX file must have at least one defined.\n");
		*pReturnError = errorMsg;
		return false;
	}

	for(i = 0; i < m_nNumEffects; ++i)
	{
		for(j = 0; j < m_psEffect[i].nNumTextures; ++j)
		{
			for(k = 0; k < m_nNumTextures; ++k)
			{
				if(strcmp(m_psEffect[i].psTextures[j].pszName, m_psTexture[k].pszName) == 0)
					break;
			}
			
			if(!m_nNumTextures || k == m_nNumTextures)
			{
				sprintf(errorMsg, "Error: TEXTURE '%s' is not defined in [TEXTURES].\n", m_psEffect[i].psTextures[j].pszName);
				*pReturnError = errorMsg;
				return false;
			}
		}
	}

	return true;
}
예제 #4
0
TextureRender* EffectParser::ParseEffect(OverlayRenderer* renderer, Json::Value effect, Json::Value *data) {
    TextureRender* parent;
    bool hasParent = false;

    if(!effect["parent"].empty()) {
        parent = ParseEffect(renderer, effect["parent"], data);
        hasParent = true;
    }

    if(hasParent && !parent){
        FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect - failed to load parent effect");
        return NULL;
    }

    if(!effect.isMember("type") || !effect.isMember("data")){
        FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect - missing vital data for the curret effect");
        return parent;
    }

    std::string type = effect["type"].asString();

    if(!hasParent){
        //must be source effect
        if(type.compare("SolidTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (SolidTexture) - created");
            return new SolidTexture(renderer);
        } else if(type.compare("TextTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (TextTexture) - created");
            TextTexture *t = new TextTexture(renderer);
            Json::Value dat = effect["data"];
            if(dat.isMember("name") && dat.isMember("posX") && dat.isMember("posY")){
                int posX = dat["posX"].asInt();
                int posY = dat["posY"].asInt();
                string name = dat["name"].asString();
                string value = name;
                if(data->isMember(name)){
                    value = data->get(name, dat["name"]).asString();
                } else
                    FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (TextTexture) - no text fill found for '%s'", name.c_str());

                printf("hi - %s\n",value.c_str());

                t->setText(value.c_str(), renderer->getDefaultCharSet(), posX, posY, 1.0f, 1.0f);//TODO dynamicify the rest of this
            } else
                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (TextTexture) - incomplete data");

            return t;

        } else if(type.compare("PNGTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (PNGTexture) - created");
            PNGTexture *t = new PNGTexture(renderer);
            Json::Value dat = effect["data"];
            if(dat.isMember("file")){
                if(JsonUtil::FileExists(dat["file"].asString().c_str()))
                    t->LoadPNG(dat["file"].asString());
                else
                    FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (PNGTexture) - file doesnt exist");
            } else
                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (PNGTexture) - file not defined");

            return t;

        } else {
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect - unknown source");
            return NULL;
        }
    } else {
        //must be an actual effect
        if(type.compare("ColourTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (ColourTexture) - create");
            ColourTexture *t = new ColourTexture(renderer, parent);
            Json::Value dat = effect["data"];
            if(dat.isMember("red") && dat.isMember("green") && dat.isMember("blue") && dat.isMember("alpha")){
                float red = dat["red"].asFloat();
                float green = dat["green"].asFloat();
                float blue = dat["blue"].asFloat();
                float alpha = dat["alpha"].asFloat();
                t->SetColour(red, green, blue, alpha);
            } else
                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (ColourTexture) - missing colour data");

            return t;

        } else if(type.compare("FadeTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (FadeTexture) - create");
            FadeTexture *t = new FadeTexture(renderer, parent);
            Json::Value dat = effect["data"];
            if(dat.isMember("points")){
                Json::Value points = dat["points"];
                if(points.isArray() && points.size() >= 1){
                    for(Json::ValueIterator it = points.begin(); it != points.end(); it++){
                        Json::Value p = *it;
                        if(p.isMember("field") && p.isMember("alpha")){
                            int field = p["field"].asInt();
                            float alpha = p["alpha"].asFloat();
                            t->addPoint(new FadePoint(field, alpha));
                        } else
                            FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (FadeTexture) - data point is invalid");
                    }
                } else
                    FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (FadeTexture) - no data array");
            } else
                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (FadeTexture) - no data points");

            return t;

        } else if(type.compare("MaskTexture") == 0){
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect (MaskTexture) - create");
            MaskTexture *t = new MaskTexture(renderer, parent);
            Json::Value dat = effect["data"];
            if(dat.isMember("points")){
                Json::Value points = dat["points"];
                if(points.isArray() && points.size() >= 1){
                    for(Json::ValueIterator it = points.begin(); it != points.end(); it++){
                        Json::Value p = *it;
                        if(p.isMember("bl") && p.isMember("br") && p.isMember("tl") && p.isMember("tr") && p.isMember("field")){
                            Json::Value bl = p["bl"];
                            Json::Value br = p["br"];
                            Json::Value tl = p["tl"];
                            Json::Value tr = p["tr"];
                            if(bl.isMember("x") && bl.isMember("y") && br.isMember("x") && br.isMember("y") && tl.isMember("x") && tl.isMember("y") && tr.isMember("x") && tr.isMember("y")){
                                float blX = bl["x"].asFloat();
                                float blY = bl["y"].asFloat();
                                float brX = br["x"].asFloat();
                                float brY = br["y"].asFloat();
                                float tlX = tl["x"].asFloat();
                                float tlY = tl["y"].asFloat();
                                float trX = tr["x"].asFloat();
                                float trY = tr["y"].asFloat();
                                int field = p["field"].asInt();

                                t->addPoint(new MaskPoint(field, tlX, tlY, trX, trY, blX, blY, brX, brY));
                            } else
                                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (MaskTexture) - data point is invalid");
                        } else
                            FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (MaskTexture) - data point is invalid");
                    }
                }
            } else
                FLog::Log(FLOG_ERROR, "EffectParser::ParseEffect (MaskTexture) - no data points");

            return t;

        } else {
            FLog::Log(FLOG_DEBUG, "EffectParser::ParseEffect - unknown effect");
            return NULL;
        }
    }

}