DrawableLine* XmlBuilder::CreateDrawableLine(
XMLNode& node,
const Registry<JourneyPattern>& lines
){
// assert ("drawableLine" == node.getName ());
util::RegistryKeyType lineId (GetLongLongAttr (node, "lineId"));
boost::shared_ptr<const JourneyPattern> line = lines.get (lineId);
const vector<Edge*>& lineStops = line->getEdges ();
assert (lineStops.size () >= 2);
int fromLineStopIndex (GetIntAttr (node, "fromLineStopId", 0));
int toLineStopIndex (GetIntAttr (node, "toLineStopId", (int) lineStops.size () - 1));
bool withPhysicalStops (GetBoolAttr (node, "withPhysicalStops", false));
return new DrawableLine(
line.get(),
fromLineStopIndex,
toLineStopIndex,
withPhysicalStops
);
}
//-------------------------------------------------------------------------------------------------
void U2FrameXmlParser::ParseRenderTarget(TiXmlElement* elem, U2Frame* renderPath)
{
U2ASSERT(elem && renderPath);
U2FrameRenderTarget* pNewRT = U2_NEW U2FrameRenderTarget;
pNewRT->SetName(elem->Attribute("name"));
pNewRT->SetFormat(U2Dx9Texture::StringToPixelFormat(elem->Attribute("format")));
pNewRT->SetRelativeSize(GetFloatAttr(elem, "relSize", 1.0f));
if(HasAttr(elem, "width"))
{
pNewRT->SetWidth(GetIntAttr(elem, "width", 0));
}
if(HasAttr(elem, "height"))
{
pNewRT->SetHeight(GetIntAttr(elem, "height", 0));
}
renderPath->AddRenderTarget(pNewRT);
}
//DetectLevel
INT Obj_Character::GetDetectLevel(VOID)
{
if(TRUE==GetDetectLevelDirtyFlag())
{
INT nValue=GetDetectLevelRefix() + 0;//0 is base stealth level for every character
SetIntAttr(CharIntAttrs_T::ATTR_DETECT_LEVEL, nValue);
ClearDetectLevelDirtyFlag();
}
return GetIntAttr(CharIntAttrs_T::ATTR_DETECT_LEVEL);
}
//Exp Refix
INT Obj_Character::GetExpRefix(VOID)
{
if(TRUE==GetExpRefixDirtyFlag())
{
INT nValue = GetBaseExpRefix();
nValue += GetExpRefixRefix();
0>nValue?nValue=0:NULL;
MAX_EXP_REFIX_IN_CHAR<nValue?nValue=MAX_EXP_REFIX_IN_CHAR:NULL;
SetIntAttr(CharIntAttrs_T::ATTR_EXP_REFIX, nValue);
ClearExpRefixDirtyFlag();
}
return GetIntAttr(CharIntAttrs_T::ATTR_EXP_REFIX);
}
//mountID
INT Obj_Character::GetMountID(VOID)
{
if(TRUE==GetMountIDDirtyFlag())
{
INT nValue=GetMountIDRefix();
if(INVALID_ID==nValue)
{
nValue=GetBaseMountID();
}
SetIntAttr(CharIntAttrs_T::ATTR_MOUNT_ID, nValue);
ClearMountIDDirtyFlag();
}
return GetIntAttr(CharIntAttrs_T::ATTR_MOUNT_ID);
}
NS_IMETHODIMP
nsXFormsRepeatElement::GetStartingIndex(PRUint32 *aRes)
{
NS_ENSURE_ARG(aRes);
nsresult rv = GetIntAttr(NS_LITERAL_STRING("startindex"),
(PRInt32*) aRes,
nsISVSchemaBuiltinType::BUILTIN_TYPE_POSITIVEINTEGER);
if (NS_FAILED(rv)) {
*aRes = 1;
}
SanitizeIndex(aRes);
return NS_OK;
}
static BongoCalTime
CalTimeFromPy(PyObject *dt)
{
BongoCalTime t;
t = BongoCalTimeEmpty();
t.year = GetIntAttr(dt, "year", 1970);
t.month = GetIntAttr(dt, "month", 1) - 1;
t.day = GetIntAttr(dt, "day", 1);
t.hour = GetIntAttr(dt, "hour", 0);
t.minute = GetIntAttr(dt, "minute", 0);
t.second = GetIntAttr(dt, "second", 0);
return t;
}
/**
Parse a shader state element inside a Pass XML element.
*/
void U2FrameXmlParser::ParseShaderState(U2FxShaderState::Type type,
TiXmlElement* elem, U2FrameSequence* seq)
{
U2ASSERT(elem && seq);
U2FxShaderState::Param eParam = U2FxShaderState::
StringToParam(elem->Attribute("name"));
U2ShaderArg* pArg = U2_NEW U2ShaderArg(type);
if(HasAttr(elem, "value"))
{
switch(type)
{
case U2FxShaderState::Int:
pArg->SetInt(GetIntAttr(elem, "value", 0));
break;
case U2FxShaderState::Float:
pArg->SetFloat(GetFloatAttr(elem, "value", 0.0f));
break;
case U2FxShaderState::Float4:
{
U2Float4 f4 = {0.f};
pArg->SetFloat4(GetFloat4Attr(elem, "value", f4));
}
break;
case U2FxShaderState::Texture:
{
#ifdef UNICODE
const wchar_t* szFilename = ToUnicode(elem->Attribute("value"));
#else
const char* szFilename = elem->Attribute("value");
#endif
U2ASSERT(szFilename);
U2Dx9BaseTexture* pTexIter = U2Dx9BaseTexture::GetHead();
U2Dx9BaseTexture* pNexTex = 0;
while(pTexIter)
{
// Create시 SetName을 함..
if(pTexIter->GetName() == szFilename)
{
pNexTex = pTexIter;
break;
}
pTexIter = pTexIter->GetNext();
}
if(!pNexTex)
{
U2FilePath fPath;
TCHAR fullPath[256];
fPath.ConvertToAbs(fullPath, 256 * sizeof(TCHAR) , szFilename, TEXTURE_PATH);
pNexTex = U2Dx9Texture::Create(fullPath, U2Dx9Renderer::GetRenderer());
}
pArg->SetTexture(pNexTex);
}
break;
default:
FDebug("nRpXmlParser::ParseShaderState(): invalid data type '%s'!",
elem->Attribute("name"));
break;
}
seq->AddConstantShaderParam(eParam, *pArg);
}
else if(HasAttr(elem, "variable"))
{
#ifdef UNICODE
const WCHAR* szVar =ToUnicode(elem->Attribute("variable"));
#else
const char* szVar = elem->Attribute("variable");
#endif
seq->AddVariableShaderParam(szVar, eParam, *pArg);
}
}
/**
Parse a Pass element inside a Section element.
*/
void U2FrameXmlParser::ParseFramePass(TiXmlElement* elem, U2FrameSection* section)
{
U2ASSERT(elem && section);
U2FramePass* pNewPass = U2_NEW U2FramePass;
pNewPass->SetFrame(section->GetFrame());
#ifdef UNICODE
pNewPass->SetName(ToUnicode(elem->Attribute("name")));
pNewPass->SetShaderAlias(ToUnicode(elem->Attribute("shader")));
#else
pNewPass->SetName(elem->Attribute("name"));
pNewPass->SetShaderAlias(elem->Attribute("shader"));
#endif
U2DynString szRenderTarget(_T("renderTarget"));
int i=0;
unsigned int uClearFlag = 0;
#ifdef UNICODE
while(HasAttr(elem, ToAscii(szRenderTarget.Str())))
{
//pNewPass->SetRenderTargetName(i, ToUnicode(elem->Attribute(szRenderTarget.Str()));
szRenderTarget = L("renderTarget");
szRenderTarget.AppendInt(++i);
}
#else
while(HasAttr(elem, szRenderTarget.Str()))
{
pNewPass->SetRenderTargetName(i, elem->Attribute(szRenderTarget.Str()));
szRenderTarget = "renderTarget";
szRenderTarget.AppendInt(++i);
}
#endif
if(HasAttr(elem, "stats"))
{
//pNewPass->SetStatsEnabled(GetBoolAttr(elem, "stats", true));
}
int clearFlags = 0;
if(HasAttr(elem, "clearColor"))
{
uClearFlag |= U2Dx9Renderer::CLEAR_BACKBUFFER;
D3DXVECTOR4 color = GetVector4Attr(elem, "clearColor",
D3DXVECTOR4(0.f, 0.f, 0.f, 1.f));
pNewPass->SetBackgroundColor(D3DXCOLOR(color.x, color.y, color.z, color.w));
}
if(HasAttr(elem, "clearDepth"))
{
uClearFlag |= U2Dx9Renderer::CLEAR_ZBUFFER;
pNewPass->SetDepthClear(GetFloatAttr(elem, "clearDepth", 1.0f));
}
if(HasAttr(elem, "clearStencil"))
{
uClearFlag |= U2Dx9Renderer::CLEAR_STENCIL;
pNewPass->SetStencilClear(GetIntAttr(elem, "clearStencil", 0));
}
pNewPass->SetClearFlags(uClearFlag);
if(HasAttr(elem, "drawQuad"))
{
pNewPass->SetDrawFullscreenQuad(GetBoolAttr(elem, "drawQuad", false));
// CreateQuad
if (pNewPass->GetDrawFullscreenQuad())
pNewPass->CreateScreenQuad();
}
if(HasAttr(elem, "drawShadows"))
{
#ifdef UNICODE
pNewPass->SetShadowTechnique(ToUnicode(U2FramePass::StringToShadowTechnique(elem->Attribute("drawShadows"))));
#else
pNewPass->SetShadowTechnique(U2FramePass::StringToShadowTechnique(elem->Attribute("drawShadows")));
#endif
}
if(HasAttr(elem, "occlusionQuery"))
{
pNewPass->SetOcclusionQuery(GetBoolAttr(elem, "occlusionQuery", false));
}
if(HasAttr(elem, "drawGui"))
{
pNewPass->SetDrawGui(GetBoolAttr(elem, "drawGui", false));
}
if(HasAttr(elem, "technique"))
{
#ifdef UNICODE
pNewPass->SetTechnique(ToUnicode(elem->Attribute("technique")));
#else
pNewPass->SetTechnique(elem->Attribute("technique"));
#endif
}
if(HasAttr(elem, "shadowEnabledCondition"))
{
pNewPass->SetShadowEnabled(GetBoolAttr(elem, "shadowEnabledCondition", false));
}
if(HasAttr(elem, "addDepthStencil"))
{
pNewPass->SetDepthStencil(GetBoolAttr(elem, "addDepthStencil", false));
}
TiXmlElement* pChild;
for(pChild = elem->FirstChildElement(); pChild; pChild = pChild->NextSiblingElement())
{
#ifdef UNICODE
if(pChild->Value() == U2DynString(L"Float"))
{
ParseShaderState(U2FxShaderState::Float, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString(L"Float4"))
{
ParseShaderState(U2FxShaderState::Float4, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString(L"Int"))
{
ParseShaderState(U2FxShaderState::Int, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString(L"Texture"))
{
ParseShaderState(U2FxShaderState::Texture, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString(L"FramePhase"))
{
ParseFramePhase(pChild, pNewPass);
}
#else
if(pChild->Value() == U2DynString("Float"))
{
ParseShaderState(U2FxShaderState::Float, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString("Float4"))
{
ParseShaderState(U2FxShaderState::Float4, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString("Int"))
{
ParseShaderState(U2FxShaderState::Int, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString("Texture"))
{
ParseShaderState(U2FxShaderState::Texture, pChild, pNewPass);
}
else if(pChild->Value() == U2DynString("Phase"))
{
ParseFramePhase(pChild, pNewPass);
}
#endif
}
section->AddFramePass(pNewPass);
}
//-------------------------------------------------------------------------------------------------
U2Variable* U2FrameXmlParser::ParseVariable(U2Variable::Type dataType, TiXmlElement* elem)
{
U2ASSERT(elem);
const char* szVar = elem->Attribute("name");
U2ASSERT(szVar);
U2Variable::Handle varHandle = U2VariableMgr::Instance()->GetVariableHandleByName(szVar);
U2Variable* pNewVar = U2_NEW U2Variable(dataType, varHandle);
switch(dataType)
{
case U2Variable::Int:
pNewVar->SetInt(GetIntAttr(elem, "value", 0));
break;
case U2Variable::Float:
pNewVar->SetFloat(GetFloatAttr(elem, "value", 0.0f));
break;
case U2Variable::Vector4:
{
D3DXVECTOR4 v(VECTOR4_ZERO);
pNewVar->SetVector4(GetVector4Attr(elem, "value", v));
}
break;
case U2Variable::Object:
{
#ifdef UNICODE
const wchar_t* szFilename = ToUnicode(elem->Attribute("value"));
#else
const char* szFilename = elem->Attribute("value");
#endif
U2ASSERT(szFilename);
U2Dx9BaseTexture* pTexIter = U2Dx9BaseTexture::GetHead();
U2Dx9BaseTexture* pNexTex = 0;
while(pTexIter)
{
// Create시 SetName을 함..
if(pTexIter->GetName() == szFilename)
{
pNexTex = pTexIter;
break;
}
pTexIter = pTexIter->GetNext();
}
if(!pNexTex)
{
U2FilePath fPath;
TCHAR fullPath[256];
fPath.ConvertToAbs(fullPath, 256 * sizeof(TCHAR) , szFilename, TEXTURE_PATH);
pNexTex = U2Dx9Texture::Create(fullPath, U2Dx9Renderer::GetRenderer());
}
pNewVar->SetObj(pNexTex);
}
break;
default:
U2ASSERT(false);
FDebug("nRpXmlParser::ParseGlobalVariable(): invalid datatype for variable '%s'!",
szVar);
break;
}
return pNewVar;
}
Map*
XmlBuilder::CreateMap (XMLNode& node, const Registry<JourneyPattern>& lines)
{
// assert ("map" == node.getName ());
int outputWidth (GetIntAttr (node, "outputWidth", -1));
int outputHeight (GetIntAttr (node, "outputHeight", -1));
// Drawable lines
std::set<DrawableLine*> selectedLines;
int nbDrawableLines = node.nChildNode ("drawableLine");
for (int i=0; i<nbDrawableLines; ++i)
{
XMLNode drawableLineNode = node.getChildNode ("drawableLine", i);
selectedLines.insert (CreateDrawableLine (drawableLineNode, lines));
}
const MapBackgroundManager* mbm = 0;
std::string backgroundId (GetStringAttr (node, "backgroundId", ""));
if (backgroundId != "")
{
try
{
mbm = MapBackgroundManager::GetMapBackgroundManager (backgroundId);
}
catch (synthese::Exception& ex)
{
Log::GetInstance ().warn ("Cannot find background", ex);
}
}
std::string urlPattern (GetStringAttr (node, "urlPattern", ""));
Map* map = 0;
bool preserveRatio (GetBoolAttr (node, "preserveRatio", true));
double neighborhood (GetDoubleAttr (node, "neighborhood", 0.0));
// If one of the 4 coordinates is missing, let the autofit
// feature process the right rectangle
if (
(HasAttr (node, "lowerLeftLatitude") == false) ||
(HasAttr (node, "lowerLeftLongitude") == false) ||
(HasAttr (node, "upperRightLatitude") == false) ||
(HasAttr (node, "upperRightLongitude") == false)
)
{
map = new Map (selectedLines,
outputWidth,
outputHeight,
neighborhood,
preserveRatio,
mbm, urlPattern);
}
else
{
double lowerLeftLatitude (GetDoubleAttr (node, "lowerLeftLatitude"));
double lowerLeftLongitude (GetDoubleAttr (node, "lowerLeftLongitude"));
double upperRightLatitude (GetDoubleAttr (node, "upperRightLatitude"));
double upperRightLongitude (GetDoubleAttr (node, "upperRightLongitude"));
map = new Map (selectedLines,
Rectangle (lowerLeftLatitude,
lowerLeftLongitude,
upperRightLatitude - lowerLeftLatitude,
upperRightLongitude - lowerLeftLongitude),
outputWidth,
outputHeight,
preserveRatio,
mbm, urlPattern);
}
bool lineGrouping (GetBoolAttr (node, "lineGrouping", true));
if (lineGrouping) map->setLineGrouping (lineGrouping);
return map;
}
