232 lines
8.4 KiB
Plaintext
Executable File
232 lines
8.4 KiB
Plaintext
Executable File
struct RstExpressionFinder
|
|
(
|
|
expressionToUse = undefined,
|
|
|
|
fn getDlcBranch pathArg stopConcatAt:"art" =
|
|
(
|
|
local branch = ""
|
|
local stopConcat = false
|
|
local pathPartArr = filterString pathArg "/\\" splitEmptyTokens:false
|
|
|
|
for part in pathPartArr do
|
|
(
|
|
if not stopConcat do
|
|
(
|
|
if finditem pathPartArr part > 1 do branch += "/"
|
|
|
|
if ((stricmp part stopConcatAt) == 0) then
|
|
(
|
|
stopConcat = true
|
|
)
|
|
else branch += part
|
|
)
|
|
)
|
|
return branch
|
|
),
|
|
|
|
-- Gets the ped meta and syncs it
|
|
fn getPedMeta branch =
|
|
(
|
|
local pedMetaPath = branch + "build/dev_ng/common/data/peds.meta"
|
|
try(gRsPerforce.sync pedMetaPath callerName:"ExpressionFinder" force:true)catch("Problem syncing ped meta.")
|
|
return pedMetaPath
|
|
),
|
|
|
|
-- Gets the expression set from meta
|
|
fn getExpressionSet metaPath currCharName =
|
|
(
|
|
local doc = dotNetObject "System.Xml.XmlDocument"
|
|
doc.load metaPath
|
|
|
|
local root = doc.childNodes.ItemOf[1] -- 0 is the xml header node
|
|
local rootChildCount = root.childNodes.count
|
|
|
|
-- Get the InitDatas node, where we search for our character
|
|
local initDatasNode = undefined
|
|
for childNum=0 to rootChildCount-1 do
|
|
(
|
|
local currNode = root.childNodes.ItemOf[childNum]
|
|
if currNode.Name == "InitDatas" do initDatasNode = currNode
|
|
)
|
|
|
|
if (initDatasNode != undefined) do
|
|
(
|
|
local exprSetName = undefined
|
|
local itemNodeCount = initDatasNode.childNodes.count
|
|
for itemNodeNum=0 to itemNodeCount-1 do
|
|
(
|
|
if (exprSetName == undefined) do
|
|
(
|
|
local itemNode = initDatasNode.childNodes.ItemOf[itemNodeNum]
|
|
for itemParamNum=0 to itemNode.childNodes.count-1 do
|
|
(
|
|
local currItemParamNode = itemNode.childNodes.ItemOf[itemParamNum]
|
|
if (currItemParamNode.Name == "Name") and (stricmp currItemParamNode.InnerText currCharName == 0) do
|
|
(
|
|
local targetItemNode = itemNode
|
|
-- Search the same itemNode for the ExpressionDictionaryName
|
|
for targetItemParamNum=0 to targetItemNode.childNodes.count-1 do
|
|
(
|
|
local targetParamNode = targetItemNode.childNodes.ItemOf[targetItemParamNum]
|
|
if targetParamNode.Name == "ExpressionDictionaryName" do
|
|
(
|
|
exprSetName = targetParamNode.InnerText
|
|
return exprSetName
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
fn getExpressionOrderDict exprFiles =
|
|
(
|
|
local exprOrderDict = #()
|
|
|
|
-- Get the setup xmls
|
|
for exprFile in exprFiles do
|
|
(
|
|
if (matchPattern exprFile pattern:"*assets_ng*") do -- Check if the found file is in the assets_ng directory
|
|
(
|
|
local orderVal = 0
|
|
|
|
local exprFile_local = gRsPerforce.depot2local exprFile -- The local file path
|
|
local xmlPathBase = this.getDlcBranch exprFile_local stopConcatAt:"assets_ng"-- Get the dlc branch
|
|
local xmlPath = xmlPathBase + "build/dev_ng/setup2.xml"
|
|
gRsPerforce.sync xmlPath force:true
|
|
|
|
if doesFileExist xmlPath do
|
|
(
|
|
local doc = dotNetObject "System.Xml.XmlDocument"
|
|
doc.Load xmlPath
|
|
|
|
local setupDataNode = doc.childNodes.ItemOf[1] -- 0 is the xml header node
|
|
local setupDataChildCount = setupDataNode.childNodes.count
|
|
for dataNodeNum=0 to setupDataChildCount-1 do
|
|
(
|
|
local dataNode = setupDataNode.childNodes.ItemOf[dataNodeNum]
|
|
|
|
if (stricmp dataNode.Name "order" == 0) do
|
|
(
|
|
try(orderVal = dataNode.Attributes.ItemOf["value"].Value)catch()
|
|
)
|
|
)
|
|
)
|
|
-- Add the expr file and its pack order value to a dict for comparison
|
|
append exprOrderDict (dataPair expression:exprFile orderValue:(orderVal as integer))
|
|
)
|
|
)
|
|
|
|
return exprOrderDict
|
|
),
|
|
|
|
fn getHighestExpr exprOrderDict =
|
|
(
|
|
local exprToUse = undefined
|
|
local exprVal = -1
|
|
|
|
for dp in exprOrderDict do
|
|
(
|
|
if dp.orderValue > exprVal do
|
|
(
|
|
exprToUse = dp.expression
|
|
exprVal = dp.orderValue
|
|
)
|
|
)
|
|
return exprToUse
|
|
),
|
|
|
|
fn run triggeredByUser:false =
|
|
(
|
|
-- Abort if a max file is not open
|
|
if (maxFileName == "") do
|
|
(
|
|
if triggeredByUser do
|
|
(
|
|
messageBox "Please run this within the max file of the target ped."
|
|
)
|
|
print "Please run this within the max file of the target ped."
|
|
return false
|
|
)
|
|
|
|
-- Launch a progress indicator
|
|
progressStart "Finding Expression..."
|
|
|
|
-- Init the expression field of the struct
|
|
this.expressionToUse = undefined
|
|
|
|
-- Connect to p4
|
|
gRsPerforce.Connect()
|
|
|
|
progressUpdate 10
|
|
|
|
--local maxPath = RsMakeSafeSlashes (toLower (getUserProp selection[1] "UDP3DSMAX")) -- UDP usage discarded
|
|
local maxPath = RsMakeSafeSlashes (toLower (maxFilePath + maxFileName))
|
|
local maxPath_parts = filterString maxPath "/" splitEmptyTokens:false
|
|
local projectRoot = maxPath_parts[1] + "/" + maxPath_parts[2]
|
|
|
|
-- Store character name
|
|
local charName = getFileNameFile maxPath
|
|
local exprSetname = undefined
|
|
|
|
-- Find DLC Pack for the current file
|
|
local devBranch = "assets_ng"
|
|
local dlcBranch = getDlcBranch maxPath stopConcatAt:"art"
|
|
|
|
progressUpdate 25
|
|
|
|
-- Get the ped meta
|
|
local pedMeta = this.getPedMeta dlcBranch
|
|
|
|
-- Get the expression set from the ped meta
|
|
local exprSetName = this.getExpressionSet pedMeta charName
|
|
|
|
progressUpdate 35
|
|
|
|
-- Search perforce for the .expr files (OLDER METHOD)
|
|
/*
|
|
pathBase = projectRoot + "/mpPacks"
|
|
pathTrail = "anim/expressions/" + exprSetName + "/Components/Head_000_R.expr"
|
|
p4SearchPath = pathBase + "..." + pathTrail
|
|
local exprRecords = gRsPerforce.FILES p4SearchPath
|
|
*/
|
|
|
|
progressUpdate 50
|
|
|
|
-- Search perforce for the .expr files
|
|
local exprRecords = #()
|
|
local pathTrail = "anim/expressions/" + exprSetName + "/Components/Head_000_R.expr"
|
|
local pathBases = #((projectRoot + "/mpPacks/"), "//depot/gta5/assets_ng/")
|
|
for pBase in pathBases do
|
|
(
|
|
local p4SearchPath = pBase + "..." + pathTrail
|
|
local eRecords = gRsPerforce.FILES p4SearchPath
|
|
if (eRecords.count > 0) do join exprRecords eRecords
|
|
)
|
|
makeUniqueArray exprRecords
|
|
|
|
progressUpdate 75
|
|
|
|
-- Get all expressions and their order value from its build xml
|
|
local exprOrderDict = this.getExpressionOrderDict exprRecords
|
|
|
|
-- Get the final expression to use, i.e. the one with the highest pack order
|
|
local finalExpr_depot = this.getHighestExpr exprOrderDict
|
|
gRsPerforce.sync finalExpr_depot
|
|
this.expressionToUse = gRsPerforce.depot2local finalExpr_depot
|
|
|
|
progressUpdate 85
|
|
|
|
if (this.expressionToUse != undefined) then
|
|
(
|
|
print("Expression Found: " + (this.expressionToUse as string))
|
|
)
|
|
else print("Could not find expression for target ped.")
|
|
|
|
progressUpdate 100
|
|
progressEnd()
|
|
)
|
|
|
|
) |