pugi::xml_node Syscfg::GetNode(const char * name)
{
pugi::xml_node node = GetRootNode().child(name);
if (!node)
node = GetRootNode().append_child(name);
return node;
}
/**
* Moves a node to other branch.
* @param refNode Reference node.
* @param moveNode Node to be moved.
* @param position Position of the moved node.
*/
void VDFTree::MoveToBranch(VDFNode *refNode, VDFNode *moveNode, VDF_MOVEPOS position)
{
VDFNode *targetPrevious;
VDFNode *targetNext;
VDFNode *srcPrevious;
VDFNode *srcNext;
if(refNode == NULL || moveNode == NULL || refNode == moveNode)
return;
if(!IsTreeNode(refNode) || !IsTreeNode(moveNode))
return;
targetPrevious = refNode->previousNode;
targetNext = refNode->nextNode;
srcPrevious = moveNode->previousNode;
srcNext = moveNode->nextNode;
if(position == VDF_MOVEPOS_AFTER) {
if(srcPrevious == NULL) {
if(moveNode->parentNode)
moveNode->parentNode->childNode = srcNext;
}
refNode->nextNode = moveNode;
moveNode->previousNode = refNode;
moveNode->nextNode = targetNext;
if(targetNext != NULL)
targetNext->previousNode = moveNode;
if(moveNode == rootNode)
rootNode = GetRootNode(moveNode);
}
else {
if(srcPrevious == NULL) {
if(moveNode->parentNode)
moveNode->parentNode->childNode = srcNext;
}
refNode->previousNode = moveNode;
moveNode->nextNode = refNode;
moveNode->previousNode = targetPrevious;
if(moveNode == rootNode)
rootNode = GetRootNode(moveNode);
else if(refNode == rootNode)
rootNode = moveNode;
}
if(srcNext)
srcNext->previousNode = srcPrevious;
if(srcPrevious)
srcPrevious->nextNode = srcNext;
}
void CTreeWnd::Layout(CRect& area)
{
if (m_style & MTS_HEADER)
{
m_pHeader->SetWindowPos(NULL,area.left,area.top,area.Width(),DEF_HDR_HEIGHT,SWP_NOZORDER);
}
// No nodes in the tree, so quit without doing anything.
if (!GetRootNode())
{
ClearAllShapes();
return;
}
// Set up first visible node if it isn't already.
if (!m_firstVisible)
{
m_firstVisible = GetRootNode();
}
// Skip root node if we need to...
if (m_firstVisible == GetRootNode() && (!(m_style & MTS_SHOWROOT)))
{
m_firstVisible = m_firstVisible->FirstChild();
}
// build list of shapes for m_rendering.
m_rendering = false;
mtNode* pNode = m_pTree->getRoot();
if (!(m_style & MTS_SHOWROOT))
pNode = pNode->firstChild();
CRect shapeArea = area;
if (pNode)
{
if (m_style & MTS_HEADER)
shapeArea.OffsetRect(0,DEF_HDR_HEIGHT);
shapeArea.bottom = shapeArea.top + DEF_NODE_HEIGHT;
ClearAllShapes();
BuildNodeShapes(pNode,shapeArea,area,0);
}
// If we've got some space left and the first node isn't the root, then
// re-layout.
int extraSpace = area.bottom - shapeArea.bottom;
if (extraSpace >= (DEF_NODE_HEIGHT*2) && m_firstVisible != GetRootNode())
{
int numNodes = extraSpace / DEF_NODE_HEIGHT;
while (numNodes > 0 && m_firstVisible)
{
m_firstVisible = m_firstVisible->PrevNode();
numNodes--;
}
}
m_dirtyLayout = false;
}
void GameView::UpdateCamera()
{
bool bAnooneAline = false;
for (Player* p : m_players)
{
if (p->IsAlive())
{
bAnooneAline = true;
break;
}
}
if (bAnooneAline)
{
// Fit players in view
Vector2 minPlayer((float)m_pTilemap->getWidth(), (float)m_pTilemap->getHeight());
Vector2 maxPlayer(0.f);
for (auto pPlayer : m_players)
{
minPlayer.x = onut::min(pPlayer->GetPosition().x, minPlayer.x);
minPlayer.y = onut::min(pPlayer->GetPosition().y, minPlayer.y);
maxPlayer.x = onut::max(pPlayer->GetPosition().x, maxPlayer.x);
maxPlayer.y = onut::max(pPlayer->GetPosition().y, maxPlayer.y);
}
minPlayer.x -= 3;
minPlayer.y -= 3;
maxPlayer.x += 3;
maxPlayer.y += 3;
m_camera = (minPlayer + maxPlayer) * .5f;
float playerViewHeight = maxPlayer.y - minPlayer.y;
float zoomH = OScreenHf / playerViewHeight;
if (zoomH > 64.f) zoomH = 64.f;
float playerViewWidth = maxPlayer.x - minPlayer.x;
float zoomW = OScreenWf / playerViewWidth;
if (zoomW > 64.f) zoomW = 64.f;
m_zoom = onut::min(zoomW, zoomH);
}
// Animate to target position
m_cameraReal = Vector2::Lerp(m_cameraReal, m_camera, ODT * 1.5f);
m_zoomReal = lerpf(m_zoomReal, m_zoom, ODT * 4.f);
// Update camera based on the players position
GetRootNode()->SetScale(Vector2(m_zoomReal));
GetRootNode()->SetPosition(-m_cameraReal * m_zoomReal + OScreenf * .5f);
}
void CTreeWnd::SetFirstVisibleNode()
{
m_firstVisibleIdx = 0;
int index = GetScrollPos32(SB_VERT);
CTreeNode* pNode = GetRootNode();
if (!pNode)
return;
if (!(m_style & MTS_SHOWROOT))
pNode = pNode->FirstChild();
m_firstVisible = pNode;
int pos = 0;
while (pNode && pos < index)
{
pos ++;//= DEF_NODE_HEIGHT;
pNode = pNode->NextNode();
if (pNode)
{
m_firstVisible = pNode;
m_firstVisibleIdx++;
}
}
}
void RadialPlot::RefreshTree(void const *startNode, int _maxLevel, int _maxValue)
{
if (!startNode)
startNode = GetRootNode();
if (!startNode)
return;
numItems = 0;
maxLevel = _maxLevel;
autoLevel = !maxLevel;
maxValue = _maxValue;
unsigned int val = GetValue(startNode);
if (!val)
val = 1;
if (val > maxValue)
{
maxValue = val;
}
ScanTree(startNode, 0, 0, M_PI * 2 * val / maxValue);
}
void SDetailsViewBase::UpdateFilteredDetails()
{
auto RootPropertyNode = GetRootNode();
if (RootPropertyNode.IsValid())
{
RootPropertyNode->FilterNodes(CurrentFilter.FilterStrings);
RootPropertyNode->ProcessSeenFlags(true);
for (int32 NodeIndex = 0; NodeIndex < ExternalRootPropertyNodes.Num(); ++NodeIndex)
{
TSharedPtr<FPropertyNode> PropertyNode = ExternalRootPropertyNodes[NodeIndex].Pin();
if (PropertyNode.IsValid())
{
PropertyNode->FilterNodes(CurrentFilter.FilterStrings);
PropertyNode->ProcessSeenFlags(true);
}
}
if (DetailLayout.IsValid())
{
DetailLayout->FilterDetailLayout(CurrentFilter);
}
RootTreeNodes = DetailLayout->GetRootTreeNodes();
}
RefreshTree();
}
void SDetailsViewBase::RestoreExpandedItems(TSharedPtr<FPropertyNode> InitialStartNode)
{
auto RootPropertyNode = GetRootNode();
check(RootPropertyNode.IsValid());
TSharedPtr<FPropertyNode> StartNode = InitialStartNode;
if (!StartNode.IsValid())
{
StartNode = RootPropertyNode;
}
ExpandedDetailNodes.Empty();
TArray<FString> ExpandedPropertyItems;
FString ExpandedCustomItems;
UStruct* BestBaseStruct = RootPropertyNode->GetBaseStructure();
//while a valid class, and we're either the same as the base class (for multiple actors being selected and base class is AActor) OR we're not down to AActor yet)
for (UStruct* Struct = BestBaseStruct; Struct && ((BestBaseStruct == Struct) || (Struct != AActor::StaticClass())); Struct = Struct->GetSuperStruct())
{
GConfig->GetSingleLineArray(TEXT("DetailPropertyExpansion"), *Struct->GetName(), ExpandedPropertyItems, GEditorPerProjectIni);
SetExpandedItems(StartNode, ExpandedPropertyItems);
}
if (BestBaseStruct)
{
GConfig->GetString(TEXT("DetailCustomWidgetExpansion"), *BestBaseStruct->GetName(), ExpandedCustomItems, GEditorPerProjectIni);
TArray<FString> ExpandedCustomItemsArray;
ExpandedCustomItems.ParseIntoArray(ExpandedCustomItemsArray, TEXT(","), true);
ExpandedDetailNodes.Append(ExpandedCustomItemsArray);
}
}
void SDetailsViewBase::UpdatePropertyMap()
{
// Reset everything
ClassToPropertyMap.Empty();
ClassesWithProperties.Empty();
// We need to be able to create a new detail layout and properly clean up the old one in the process
check(!DetailLayout.IsValid() || DetailLayout.IsUnique());
RootTreeNodes.Empty();
DetailLayout = MakeShareable(new FDetailLayoutBuilderImpl(ClassToPropertyMap, PropertyUtilities.ToSharedRef(), SharedThis(this)));
auto RootPropertyNode = GetRootNode();
check(RootPropertyNode.IsValid());
// Currently object property nodes do not provide any useful information other than being a container for its children. We do not draw anything for them.
// When we encounter object property nodes, add their children instead of adding them to the tree.
UpdatePropertyMapRecursive(*RootPropertyNode, *DetailLayout, NAME_None, RootPropertyNode.Get());
CustomUpdatePropertyMap();
// Ask for custom detail layouts, unless disabled. One reason for disabling custom layouts is that the custom layouts
// inhibit our ability to find a single property's tree node. This is problematic for the diff and merge tools, that need
// to display and highlight each changed property for the user. We could whitelist 'good' customizations here if
// we can make them work with the diff/merge tools.
if( !bDisableCustomDetailLayouts )
{
QueryCustomDetailLayout(*DetailLayout);
}
DetailLayout->GenerateDetailLayout();
UpdateFilteredDetails();
}
void
PhraseDictionaryMemory::
GetTargetPhraseCollectionBatch(const InputPathList &inputPathQueue) const
{
InputPathList::const_iterator iter;
for (iter = inputPathQueue.begin(); iter != inputPathQueue.end(); ++iter) {
InputPath &node = **iter;
const Phrase &phrase = node.GetPhrase();
const InputPath *prevPath = node.GetPrevPath();
const PhraseDictionaryNodeMemory *prevPtNode = NULL;
if (prevPath) {
prevPtNode = static_cast<const PhraseDictionaryNodeMemory*>(prevPath->GetPtNode(*this));
} else {
// Starting subphrase.
assert(phrase.GetSize() == 1);
prevPtNode = &GetRootNode();
}
if (prevPtNode) {
Word lastWord = phrase.GetWord(phrase.GetSize() - 1);
lastWord.OnlyTheseFactors(m_inputFactors);
const PhraseDictionaryNodeMemory *ptNode = prevPtNode->GetChild(lastWord);
if (ptNode) {
const TargetPhraseCollection &targetPhrases = ptNode->GetTargetPhraseCollection();
node.SetTargetPhrases(*this, &targetPhrases, ptNode);
} else {
node.SetTargetPhrases(*this, NULL, NULL);
}
}
}
}
nsresult nsWebBrowserFind::SetRangeAroundDocument(nsIDOMRange* aSearchRange,
nsIDOMRange* aStartPt,
nsIDOMRange* aEndPt,
nsIDOMDocument* aDoc)
{
nsCOMPtr<nsIDOMNode> bodyNode;
nsresult rv = GetRootNode(aDoc, getter_AddRefs(bodyNode));
nsCOMPtr<nsIContent> bodyContent (do_QueryInterface(bodyNode));
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_ARG_POINTER(bodyContent);
uint32_t childCount = bodyContent->GetChildCount();
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
if (mFindBackwards)
{
aStartPt->SetStart(bodyNode, childCount);
aStartPt->SetEnd(bodyNode, childCount);
aEndPt->SetStart(bodyNode, 0);
aEndPt->SetEnd(bodyNode, 0);
}
else
{
aStartPt->SetStart(bodyNode, 0);
aStartPt->SetEnd(bodyNode, 0);
aEndPt->SetStart(bodyNode, childCount);
aEndPt->SetEnd(bodyNode, childCount);
}
return NS_OK;
}
long CTreeWnd::GetScrollExtent(int nBar)
{
int extent = 0;
if (nBar == SB_HORZ)
{
for (int i = 0; i < m_pHeader->GetNumPanes(); i++)
{
extent += m_pHeader->GetPaneWidth(i);
}
}
else if (nBar == SB_VERT)
{
// vertical scroll size is total height of all expanded nodes...
CTreeNode* pNode = GetRootNode();
if (pNode && (!(m_style & MTS_SHOWROOT)))
pNode = pNode->FirstChild();
bool done = false;
while (pNode && !done)
{
//extent += DEF_NODE_HEIGHT;
extent++;
CTreeNode* pNext = pNode->NextNode();
if (pNext == pNode)
done = true;
else
pNode = pNext;
}
}
return extent;
}
void SGP_MaxInterface::GetNodeTree( INode* pNode )
{
if( pNode == NULL )
{
pNode = GetRootNode();
}
if( !pNode )
return;
if( pNode != GetRootNode() )
m_vectorNode.add( pNode );
for (int i = 0; i < pNode->NumberOfChildren(); i++)
{
GetNodeTree( pNode->GetChildNode( i ) );
}
}
void Tree<N>::CollapseNodes(float support)
{
std::queue<N*> queue;
std::vector<N*> children = GetRootNode()->GetChildren();
foreach(N* child, children)
{
queue.push(child);
}
NS_IMETHODIMP
inDOMView::Rebuild()
{
nsCOMPtr<nsIDOMNode> root;
GetRootNode(getter_AddRefs(root));
SetRootNode(root);
return NS_OK;
}
// ****************************************************************************
// Method: AccessViewerSession::WriteConfigFile
//
// Purpose:
// Writes the modified data tree to a session file.
//
// Arguments:
// filename : The name of the file to write.
//
// Programmer: Brad Whitlock
// Creation: Mon Nov 13 15:45:25 PST 2006
//
// Modifications:
//
// ****************************************************************************
bool
AccessViewerSession::WriteConfigFile(std::ostream& out)
{
// Write the output file to stdout for now.
out << "<?xml version=\"1.0\"?>\n";
WriteObject(out, GetRootNode());
return true;
}
// ****************************************************************************
// Method: AccessViewerSession::ReadConfigFile
//
// Purpose:
// Reads the session file and stores it internally.
//
// Arguments:
// filename : The name of the session file to open.
//
// Returns: A pointer to the root data node or 0.
//
// Programmer: Brad Whitlock
// Creation: Mon Nov 13 15:44:26 PST 2006
//
// Modifications:
// Brad Whitlock, Tue Apr 22 12:19:30 PDT 2008
// Skip the XML tag.
//
// ****************************************************************************
DataNode *
AccessViewerSession::ReadConfigFile(std::istream& in)
{
// Skip the XML tag
FinishTag(in);
root = new DataNode("root");
ReadObject(in, root);
return GetRootNode();
}
void SceneManager3D::Render( tRendererType *renderer )
{
assert( renderer );
renderer->SetViewport( &GetCamera()->GetViewport() );
renderer->BeginFrame();
RenderVisitor<tRendererType> visitor;
visitor.SetRenderer( renderer );
visitor.SetCamera( GetCamera() );
visitor.Visit( GetRootNode() );
renderer->EndFrame();
renderer->SetViewport( NULL );
}
bool FXmlFile::Save(const FString& Path)
{
FString Xml;
Xml += TEXT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>") LINE_TERMINATOR;
TArray<const FXmlNode*> NodeStack;
static const TCHAR Tabs[] = TEXT("\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t");
auto Indent = &Tabs[ARRAY_COUNT(Tabs) - 1];
const auto* CurrentNode = GetRootNode();
while (CurrentNode)
{
if (auto Child = CurrentNode->GetFirstChildNode())
{
NodeStack.Push(CurrentNode);
Xml += FString::Printf(TEXT("%s<%s>") LINE_TERMINATOR, Indent, *CurrentNode->GetTag());
CurrentNode = Child;
// Actually increases the indent by one tab
--Indent;
continue;
}
auto Tag = *CurrentNode->GetTag();
Xml += FString::Printf(TEXT("%s<%s>%s</%s>") LINE_TERMINATOR, Indent, Tag, *CurrentNode->GetContent(), Tag);
CurrentNode = CurrentNode->GetNextNode();
while (!CurrentNode && NodeStack.Num() != 0)
{
// Actually decreases the indent by one tab
++Indent;
CurrentNode = NodeStack.Pop();
Xml += FString::Printf(TEXT("%s</%s>") LINE_TERMINATOR, Indent, *CurrentNode->GetTag());
CurrentNode = CurrentNode->GetNextNode();
}
}
TUniquePtr<FArchive> Archive(IFileManager::Get().CreateFileWriter(*Path));
if (!Archive)
{
ErrorMessage = NSLOCTEXT("XmlParser", "FileSaveFail", "Failed to save the file").ToString();
ErrorMessage += FString::Printf(TEXT("\"%s\""), *Path);
return false;
}
FTCHARToUTF8 Converter(*Xml);
Archive->Serialize(const_cast<char*>(Converter.Get()), Converter.Length());
return true;
}
int CMapFileIO::SaveMap(const CLevelMap &map, HANDLE hFile) const
{
XML_MANAGER_HANDLE xml = 0;
std::wostringstream os;
xml = CreateWorker();
if(!xml)
return 1;
BeginDoc(xml, L"map");
XML_NODE_HANDLE root = GetRootNode(xml);
if(!root)
return 1;
XML_NODE_HANDLE node;
int w, h;
D3DXVECTOR3 pos;
//dimensions
node = AddNode(xml, root, L"dimensions");
if(!node)
return 1;
w = map.GetWidth();
h = map.GetHeight();
os << w;
SetNodeAttr(xml, node, L"width", os.str().c_str());
os.str(L"");
os << h;
SetNodeAttr(xml, node, L"height", os.str().c_str());
os.str(L"");
ReleaseNode(node);
//background
SaveBackground(*map.GetBackground(), xml, root);
//player
SavePlayer( map.GetPlayer(), xml, root );
//tiles
SaveTileList(map.m_pTiles, xml, root);
//creatures
SaveCreatureList(map.m_pCreatures, xml, root);
SaveToFileHandle(xml, hFile, true);
CloseHandle(hFile);
ReleaseWorker(xml);
return 0;
}
void GameView::OnRender()
{
if (m_gameover)
return;
#if defined(_DEBUG)
auto pFont = OGetBMFont("font.fnt");
pFont->draw("Time: " + std::to_string(GetDayTimeHour()), Vector2::Zero);
switch (GetTimeOfDay())
{
case TimeOfDay::Night:
pFont->draw("Night", Vector2(0, 20));
break;
case TimeOfDay::Dawn:
pFont->draw("Dawn", Vector2(0, 20));
break;
case TimeOfDay::Day:
pFont->draw("Day", Vector2(0, 20));
break;
case TimeOfDay::Dusk:
pFont->draw("Dusk", Vector2(0, 20));
break;
}
pFont->draw("Monster spawn Rate: " + std::to_string(GetMonsterSpawnRate()), Vector2(0, 40));
pFont->draw("Monster count: " + std::to_string(Monster::count), Vector2(0, 60));
pFont->draw("Day: " + std::to_string(m_day), Vector2(0, 80));
#if 0 // Show path
OSB->end();
for (auto pEntity : m_entities)
{
auto pMonster = dynamic_cast<Monster*>(pEntity);
if (pMonster)
{
OPB->begin(onut::ePrimitiveType::LINE_STRIP, nullptr, GetRootNode()->GetTransform());
for (auto& p : pMonster->m_path)
{
OPB->draw(p);
}
OPB->end();
}
}
OSB->begin();
#endif
#endif
}
/*
Function name : CXML::LoadFile
Description : This function load the given XML file using
m_pXMLDoc object.
Return type : bool
Argument : LPCTSTR lpszXmlFile
Tested : Ok
*/
bool CXML::LoadFile(LPCTSTR lpszXmlFile)
{
if (!lpszXmlFile || !m_pXMLDoc)
return false;
m_csXmlFileName = lpszXmlFile;
long lXmlSate = 0;
_variant_t vtFileName(m_csXmlFileName);
VARIANT_BOOL vSuccess;
m_hr = m_pXMLDoc->load(vtFileName,&vSuccess);
if(!SUCCEEDED(m_hr) || vSuccess == FALSE)
{
return FALSE;
}
m_hr = m_pXMLDoc->get_readyState(&lXmlSate);
if(SUCCEEDED(m_hr) && lXmlSate == 4)
{
m_hr = m_pXMLDoc->get_documentElement(&m_pIRootElement);
if(SUCCEEDED(m_hr) == 0)
return false;
BSTR bstrTagName;
m_pIRootElement->get_tagName(&bstrTagName);
CString csRootTag = bstrTagName;
SysFreeString(bstrTagName);
if(GetRootNode(csRootTag))
{
m_pICurrentNode = m_pIRootNode;
m_pICurrentNode->AddRef();
}
else
return false;
}
else
return false;
return true;
}
/*
Function name : CXML::LoadString
Description : This function load the given XML String using
m_pXMLDoc object.
Return type : bool
Argument : LPCTSTR lpszXmlFile
Tested : Ok
*/
bool CXML::LoadString(LPCTSTR lpszXmlString)
{
if (!lpszXmlString || !m_pXMLDoc)
return false;
_bstr_t bstrXMLString(lpszXmlString);
long lXmlSate = 0;
VARIANT_BOOL vSuccess;
m_hr = m_pXMLDoc->loadXML(bstrXMLString,&vSuccess);
if(!SUCCEEDED(m_hr) || vSuccess == FALSE)
{
return FALSE;
}
m_hr = m_pXMLDoc->get_readyState(&lXmlSate);
if(SUCCEEDED(m_hr) && lXmlSate == 4)
{
m_hr = m_pXMLDoc->get_documentElement(&m_pIRootElement);
if(!SUCCEEDED(m_hr))
return false;
BSTR bstrTagName;
m_pIRootElement->get_tagName(&bstrTagName);
CString csRootTag;
csRootTag = bstrTagName;
SysFreeString(bstrTagName);
if(GetRootNode(csRootTag))
{
m_pICurrentNode = m_pIRootNode;
m_pICurrentNode->AddRef();
}
else
return false;
}
else
return false;
return true;
}
bool THISCLASS::Open(const wxFileName &filename) {
// Read the file
wxLogNull log;
mIsOpen = mDocument.Load(filename.GetFullPath());
if (! mIsOpen) {
mDocument.SetRoot(new wxXmlNode(0, wxXML_ELEMENT_NODE, wxT("swistrack")));
SelectRootNode();
return false;
}
// Select the root element and check its name
SetRootNode(mDocument.GetRoot());
if (GetRootNode()->GetName() != wxT("swistrack")) {
mIsOpen = false;
return false;
}
return true;
}
bool FXmlFile::Save(const FString& Path)
{
FString Xml = TEXT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>") LINE_TERMINATOR;
const FXmlNode* CurrentNode = GetRootNode();
if(CurrentNode != nullptr)
{
WriteNodeHierarchy(*CurrentNode, FString(), Xml);
}
TUniquePtr<FArchive> Archive(IFileManager::Get().CreateFileWriter(*Path));
if (!Archive)
{
ErrorMessage = NSLOCTEXT("XmlParser", "FileSaveFail", "Failed to save the file").ToString();
ErrorMessage += FString::Printf(TEXT("\"%s\""), *Path);
return false;
}
FTCHARToUTF8 Converter(*Xml);
Archive->Serialize(const_cast<char*>(Converter.Get()), Converter.Length());
return true;
}
bool PhantomTree::SetFirstPhantomNodeToPhoton(SharedFlyingPhotonPtr &photon)
{
SharedPhantomNodePtr root =GetRootNode();
if( root.get()->IsInside( photon->GetCurrentPosition() ) ){ //Start Inside of Tree
return SetCurrentChildrenNodeToPhoton(root, photon);
}else{ //Start Outside of Tree
double t0;
if( !root.get()->GetForwardNodeRayParameter( photon->GetPhotonRay(1.0), t0) ){
return false;
}//not captured
photon->MoveForwardByRayParameter(t0);
photon->SetCurrentPhantomNode(root);
return true;
}
return false;
}
static void ParseListResults(const TArray<FXmlFile>& ResultsXml, TArray< TSharedRef<FSubversionSourceControlLabel> >& OutLabels)
{
static const FString Lists(TEXT("lists"));
static const FString List(TEXT("list"));
static const FString Path(TEXT("path"));
static const FString Entry(TEXT("entry"));
static const FString Kind(TEXT("kind"));
static const FString Dir(TEXT("dir"));
static const FString Name(TEXT("name"));
static const FString Commit(TEXT("commit"));
static const FString Revision(TEXT("revision"));
for(auto ResultIt(ResultsXml.CreateConstIterator()); ResultIt; ResultIt++)
{
const FXmlNode* ListsNode = ResultIt->GetRootNode();
if(ListsNode != NULL && ListsNode->GetTag() == Lists)
{
const TArray<FXmlNode*> ListsChildren = ListsNode->GetChildrenNodes();
for(auto ListIter(ListsChildren.CreateConstIterator()); ListIter; ListIter++)
{
const FXmlNode* ListNode = *ListIter;
if(ListNode == NULL || ListNode->GetTag() != List)
{
continue;
}
FString DirectoryPath = ListNode->GetAttribute(Path);
const TArray<FXmlNode*> ListChildren = ListNode->GetChildrenNodes();
for(auto EntryIter(ListChildren.CreateConstIterator()); EntryIter; EntryIter++)
{
const FXmlNode* EntryNode = *EntryIter;
if(EntryNode == NULL || EntryNode->GetTag() != Entry)
{
continue;
}
if(EntryNode->GetAttribute(Kind) == Dir)
{
// find a name & revision for this directory
const FXmlNode* NameNode = EntryNode->FindChildNode(Name);
if(NameNode != NULL)
{
FString LabelName = NameNode->GetContent();
if (LabelName.Len() > 0)
{
const FXmlNode* CommitNode = EntryNode->FindChildNode(Commit);
if(CommitNode != NULL)
{
FString RevisionString = CommitNode->GetAttribute(Revision);
if(RevisionString.Len() > 0)
{
int RevisionNum = FCString::Atoi(*RevisionString);
OutLabels.Add(MakeShareable(new FSubversionSourceControlLabel(LabelName, DirectoryPath / LabelName, RevisionNum)));
}
}
}
}
}
}
}
}
}
}
// Set the range to go from the end of the current selection to the
// end of the document (forward), or beginning to beginning (reverse).
// or around the whole document if there's no selection.
nsresult
nsWebBrowserFind::GetSearchLimits(nsIDOMRange* aSearchRange,
nsIDOMRange* aStartPt,
nsIDOMRange* aEndPt,
nsIDOMDocument* aDoc,
nsISelection* aSel,
bool aWrap)
{
NS_ENSURE_ARG_POINTER(aSel);
// There is a selection.
int32_t count = -1;
nsresult rv = aSel->GetRangeCount(&count);
NS_ENSURE_SUCCESS(rv, rv);
if (count < 1)
return SetRangeAroundDocument(aSearchRange, aStartPt, aEndPt, aDoc);
// Need bodyNode, for the start/end of the document
nsCOMPtr<nsIDOMNode> bodyNode;
rv = GetRootNode(aDoc, getter_AddRefs(bodyNode));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIContent> bodyContent (do_QueryInterface(bodyNode));
NS_ENSURE_ARG_POINTER(bodyContent);
uint32_t childCount = bodyContent->GetChildCount();
// There are four possible range endpoints we might use:
// DocumentStart, SelectionStart, SelectionEnd, DocumentEnd.
nsCOMPtr<nsIDOMRange> range;
nsCOMPtr<nsIDOMNode> node;
int32_t offset;
// Forward, not wrapping: SelEnd to DocEnd
if (!mFindBackwards && !aWrap)
{
// This isn't quite right, since the selection's ranges aren't
// necessarily in order; but they usually will be.
aSel->GetRangeAt(count-1, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetEndContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetEndOffset(&offset);
aSearchRange->SetStart(node, offset);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(node, offset);
aStartPt->SetEnd(node, offset);
aEndPt->SetStart(bodyNode, childCount);
aEndPt->SetEnd(bodyNode, childCount);
}
// Backward, not wrapping: DocStart to SelStart
else if (mFindBackwards && !aWrap)
{
aSel->GetRangeAt(0, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetStartContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetStartOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(node, offset);
aStartPt->SetEnd(node, offset);
aEndPt->SetStart(bodyNode, 0);
aEndPt->SetEnd(bodyNode, 0);
}
// Forward, wrapping: DocStart to SelEnd
else if (!mFindBackwards && aWrap)
{
aSel->GetRangeAt(count-1, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetEndContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetEndOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(bodyNode, 0);
aStartPt->SetEnd(bodyNode, 0);
aEndPt->SetStart(node, offset);
aEndPt->SetEnd(node, offset);
}
// Backward, wrapping: SelStart to DocEnd
else if (mFindBackwards && aWrap)
{
aSel->GetRangeAt(0, getter_AddRefs(range));
if (!range) return NS_ERROR_UNEXPECTED;
range->GetStartContainer(getter_AddRefs(node));
if (!node) return NS_ERROR_UNEXPECTED;
range->GetStartOffset(&offset);
aSearchRange->SetStart(bodyNode, 0);
aSearchRange->SetEnd(bodyNode, childCount);
aStartPt->SetStart(bodyNode, childCount);
aStartPt->SetEnd(bodyNode, childCount);
aEndPt->SetStart(node, offset);
aEndPt->SetEnd(node, offset);
}
return NS_OK;
}
THISCLASS::ConfigurationWriterXML():
ConfigurationXML(new wxXmlNode(0, wxXML_ELEMENT_NODE, wxT("swistrack")), false), mErrorList(), mDocument() {
mDocument.SetRoot(GetRootNode());
}
int _tmain(int argc, _TCHAR* argv [])
{
std::cout << "usage : FbxRerouteSkeleton.exe /m:<origin mesh and skeleton data.fbx> /m:<other origin mesh and skeleton data.fbx> /a:<animated skeleton.fbx> /o:<output fbx> [/prefix:<prefix added to each bone in animated skeleton.fbx>]" << std::endl;
std::vector<std::string> meshFiles;
std::string skeletonFile;
std::string outputPath;
std::string prefix;
for (auto ix = 1; ix < argc; ++ix){
std::wstring warg = argv[ix];
if (warg.find(L"/m:") == 0){
meshFiles.push_back(wstringToUtf8(warg.substr(3)));
}
else if (warg.find(L"/a:") == 0)
{
if (skeletonFile.size()>0){
std::wcout << L"only one animated skeleton file is allowed" << std::endl;
return -2;
}
skeletonFile = wstringToUtf8(warg.substr(3));
}
else if (warg.find(L"/o:") == 0){
if (outputPath.size() > 0){
std::wcout << L"only one output file is allowed" << std::endl;
return -3;
}
CloseHandle(CreateFile(warg.substr(3).c_str(), GENERIC_READ | GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, 0, nullptr));
outputPath = wstringToUtf8(warg.substr(3));
}
else if (warg.find(L"/prefix:") == 0){
if (prefix.size() > 0){
std::wcout << L"only one prefix is allowed" << std::endl;
return -4;
}
prefix = wstringToUtf8(warg.substr(8));
}
else{
std::wcout << L"unrecognized parameter " << warg << std::endl;
return -1;
}
}
if (meshFiles.size() == 0){
std::wcout << L"no origin mesh file" << std::endl;
return -5;
}
if (skeletonFile.size() == 0){
std::wcout << L"skeleton file unspecified" << std::endl;
return -6;
}
if (outputPath.size() == 0){
std::wcout << L"output file unspecified" << std::endl;
return -7;
}
auto fbxManager = std::unique_ptr<FbxManager, FbxManagerDeleter>( FbxManager::Create());
auto iosettings = std::unique_ptr<FbxIOSettings, FbxDeleter>(FbxIOSettings::Create(fbxManager.get(), IOSROOT));
iosettings->SetBoolProp(IMP_FBX_MATERIAL, true);
iosettings->SetBoolProp(IMP_FBX_TEXTURE, true);
iosettings->SetBoolProp(IMP_FBX_LINK, true);
iosettings->SetBoolProp(IMP_FBX_SHAPE, true);
iosettings->SetBoolProp(IMP_FBX_GOBO, true);
iosettings->SetBoolProp(IMP_FBX_ANIMATION, true);
iosettings->SetBoolProp(IMP_SKINS, true);
iosettings->SetBoolProp(IMP_DEFORMATION, true);
iosettings->SetBoolProp(IMP_FBX_GLOBAL_SETTINGS, true);
iosettings->SetBoolProp(IMP_TAKE, true);
iosettings->SetBoolProp(EXP_FBX_MATERIAL, true);
iosettings->SetBoolProp(EXP_FBX_TEXTURE, true);
iosettings->SetBoolProp(EXP_MESHPOLY, true);
iosettings->SetBoolProp(EXP_FBX_SHAPE, true);
iosettings->SetBoolProp(EXP_FBX_GOBO, true);
iosettings->SetBoolProp(EXP_FBX_ANIMATION, true);
iosettings->SetBoolProp(EXP_SKINS, true);
iosettings->SetBoolProp(EXP_DEFORMATION, true);
iosettings->SetBoolProp(EXP_FBX_GLOBAL_SETTINGS, true);
iosettings->SetBoolProp(EXP_MESHTRIANGLE, true);
iosettings->SetBoolProp(EXP_EMBEDTEXTURE, true);
fbxManager->SetIOSettings(iosettings.get());
auto importer = std::unique_ptr<FbxImporter, FbxDeleter> (FbxImporter::Create(fbxManager.get(), "SceneImporter"));
importer->Initialize(skeletonFile.c_str(), -1, iosettings.get());
auto globalScene = std::unique_ptr<FbxScene, FbxDeleter>(FbxScene::Create(fbxManager.get(), "merged scene"));
importer->Import(globalScene.get());
std::map<std::string, FbxNode*> animatedSkeletonNodesMap;
populateNodeMap(animatedSkeletonNodesMap, globalScene->GetRootNode());
for (auto& f : meshFiles){
importAdditionalFile(globalScene.get(), importer.get(), f);
}
patchSkins(globalScene->GetRootNode(), animatedSkeletonNodesMap, prefix);
auto exporter = std::unique_ptr<FbxExporter, FbxDeleter>(FbxExporter::Create(fbxManager.get(), "SceneExporter"));
auto res = exporter->Initialize(outputPath.c_str(), -1, iosettings.get());
res = exporter->Export(globalScene.get());
auto status = exporter->GetStatus();
return 0;
}
