840 lines
26 KiB
Plaintext
Executable File
840 lines
26 KiB
Plaintext
Executable File
-- Rockstar Anim Utility
|
|
-- Rockstar North
|
|
-- 26/7/2005
|
|
-- by Greg Smith
|
|
-- edited by Fraser Tomison
|
|
--
|
|
-- Set of utility functions for dealing with animations
|
|
|
|
global XMLDoc = undefined
|
|
global elmntTrackSpecs = undefined
|
|
global boneArray = #()
|
|
|
|
filein "pipeline/util/userprops.ms"
|
|
filein "pipeline/util/cloth.ms"
|
|
|
|
--------------------------------------------------------------
|
|
-- add all the nodes of a hierarchy into a list
|
|
--------------------------------------------------------------
|
|
fn RsAddHierarchyToList obj addList = (
|
|
|
|
append addList obj
|
|
|
|
for childobj in obj.children do (
|
|
|
|
RsAddHierarchyToList childobj addList
|
|
)
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileRec boneval specfile blendShapeOnly foranim formap = (
|
|
|
|
if (formap == true) or boneval.isSelected then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <nameExpr>%</nameExpr>\n" (RsRemoveSpaces boneval.name) to:specfile
|
|
format " <bIncludeChildren value=\"false\"/>\n" to:specfile
|
|
format " <Tracks>\n" to:specfile
|
|
|
|
local transVal = getuserprop boneval "exportTrans"
|
|
local scaleVal = getuserprop boneval "exportScale"
|
|
local rotVal = getuserprop boneval "exportRotation"
|
|
local bonetag = getuserprop boneval "tag"
|
|
local gentransVal = getuserprop boneval "exportGenericTrans"
|
|
local visVal = getuserprop boneval "exportVisibility"
|
|
|
|
if transVal=="" or scaleVal=="" or rotVal=="" or bonetag=="" or gentransVal=="" or visVal=="" do
|
|
(
|
|
gRsULog.LogError ("A User Property is malformed on object '" + boneval.name + "'. Line must contain only one equality sign and must have a value") context:obj
|
|
)
|
|
-- AJM: Had to convert to string as there were some tags with IDs that crashed here
|
|
local doExport = undefined==bonetag or not (matchPattern (bonetag as string) pattern:"*DO_NOT_EXPORT*")
|
|
|
|
--toleranceTransVal = getuserprop boneval "exportTransTolerance"
|
|
--toleranceRotVal = getuserprop boneval "exportRotTolerance"
|
|
|
|
if blendShapeOnly == false and doExport then (
|
|
--if true then (
|
|
|
|
if transVal == true then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>translate</inputName>\n" to:specfile
|
|
format " <outputName>trans</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
|
|
/*
|
|
if toleranceTransVal != undefined then (
|
|
|
|
format " <compressionTol value=\"%\" />\n" toleranceTransVal to:specfile
|
|
)
|
|
*/
|
|
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
else if gentransVal == true then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>genericTranslation</inputName>\n" to:specfile
|
|
format " <outputName>trans</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
if scaleVal == true then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>scale</inputName>\n" to:specfile
|
|
format " <outputName>scale</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
if rotVal != false then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>rotate</inputName>\n" to:specfile
|
|
format " <outputName>rot</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
|
|
/*
|
|
if toleranceRotVal != undefined then (
|
|
|
|
format " <compressionTol value=\"%\" />\n" toleranceRotVal to:specfile
|
|
)
|
|
*/
|
|
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
if visVal == true then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>visibility0</inputName>\n" to:specfile
|
|
format " <outputName>visibility0</outputName>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
if foranim then (
|
|
|
|
for i = 0 to 7 do (
|
|
|
|
outputName = "projectData" + (i as string)
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>%</inputName>\n" outputName to:specfile
|
|
format " <outputName>%</outputName>\n" outputName to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
)
|
|
)
|
|
|
|
format " </Tracks>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
for childobj in boneval.children do (
|
|
|
|
RsCreateSpecFileRec childobj specfile blendShapeOnly foranim formap
|
|
)
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileRecNew boneroot filename blendShapeOnly foranim formap = (
|
|
|
|
specfile = openfile filename mode:"w+"
|
|
|
|
if specfile == undefined then
|
|
(
|
|
return false
|
|
)
|
|
|
|
format "<rage__AnimExportCtrlSpec>\n" to:specfile
|
|
format " <TrackSpecs>\n" to:specfile
|
|
|
|
RsCreateSpecFileRec boneroot specfile blendShapeOnly foranim formap
|
|
|
|
format " </TrackSpecs>\n" to:specfile
|
|
format "</rage__AnimExportCtrlSpec>\n" to:specfile
|
|
|
|
close specfile
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileNew boneroot filename blendShapeOnly foranim formap useWildcard:true = (
|
|
|
|
specfile = openfile filename mode:"w+"
|
|
|
|
if specfile == undefined then
|
|
(
|
|
gRsUlog.LogError "Couldn't open/create spec file for writing." context:boneroot
|
|
return false
|
|
)
|
|
|
|
format "<rage__AnimExportCtrlSpec>\n" to:specfile
|
|
format " <TrackSpecs>\n" to:specfile
|
|
|
|
if boneroot.isSelected then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <nameExpr>root</nameExpr>\n" to:specfile
|
|
format " <bIncludeChildren value=\"false\"/>\n" to:specfile
|
|
format " <Tracks>\n" to:specfile
|
|
|
|
local transVal = getuserprop boneroot "exportTrans"
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>translate</inputName>\n" to:specfile
|
|
format " <outputName>trans</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>rotate</inputName>\n" to:specfile
|
|
format " <outputName>rot</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
for i = 0 to 7 do (
|
|
|
|
outputName = "projectData" + (i as string)
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>%</inputName>\n" outputName to:specfile
|
|
format " <outputName>%</outputName>\n" outputName to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
format " </Tracks>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
|
|
for childobj in boneroot.children do (
|
|
|
|
RsCreateSpecFileRec childobj specfile blendShapeOnly foranim formap
|
|
)
|
|
)
|
|
|
|
if useWildcard then
|
|
(
|
|
format " <Item>\n" to:specfile
|
|
format " <nameExpr>*</nameExpr>\n" to:specfile
|
|
format " <bIncludeChildren value=\"false\"/>\n" to:specfile
|
|
format " <Tracks>\n" to:specfile
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
|
|
format " <Item>\n" to:specfile
|
|
format " <inputName>rotate</inputName>\n" to:specfile
|
|
format " <outputName>rot</outputName>\n" to:specfile
|
|
format " <components>X,Y,Z</components>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
format " </Tracks>\n" to:specfile
|
|
format " </Item>\n" to:specfile
|
|
)
|
|
|
|
format " </TrackSpecs>\n" to:specfile
|
|
format "</rage__AnimExportCtrlSpec>\n" to:specfile
|
|
|
|
close specfile
|
|
true
|
|
)
|
|
|
|
fn RsCreateSpecFile boneroot filename foranim:false formap:false useWildcard:true = (
|
|
|
|
return (RsCreateSpecFileNew boneroot filename false foranim formap useWildcard:useWildcard)
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
-- Above functions edited to avoid using select as bit flag bugstar:1880733 + added xml code to clean up
|
|
--------------------------------------------------------------
|
|
|
|
fn RsCreateSpecFileRecFromArray boneval specfile blendShapeOnly foranim formap = (
|
|
|
|
if (formap == true) or findItem boneArray boneval != 0 then (
|
|
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTrackSpecs
|
|
elmntTemp = XMLDoc.createelement "nameExpr" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode (RsRemoveSpaces boneval.name) )
|
|
elmntTemp = XMLDoc.createelement "bIncludeChildren" appendTo:elmntItem
|
|
boolAttr = XMLDoc.CreateAttribute "value"
|
|
boolAttr.value = "false"
|
|
elmntTemp.Attributes.append boolAttr
|
|
elmntTracks = XMLDoc.createelement "Tracks" appendTo:elmntItem
|
|
|
|
local userProps = RsGetUserProps boneval
|
|
|
|
local bonetag
|
|
local transVal
|
|
local scaleVal
|
|
local rotVal
|
|
local gentransVal
|
|
local visVal
|
|
|
|
for prop in userProps do
|
|
(
|
|
if (prop.count != 2) then
|
|
(
|
|
-- Instead of validating every prop, only validate the ones we want
|
|
if (prop[1]!=undefined) do
|
|
(
|
|
if (prop[1]=="exportTrans" or prop[1]=="exportScale" or prop[1]=="exportRotation" or prop[1]=="tag" or prop[1]=="exportGenericTrans" or prop[1]=="exportVisibility") do
|
|
(
|
|
gRsULog.LogError ("The User Property '" + prop[1] + "' is malformed on object '" + boneval.name + "'. Line must contain only one equality sign and must have a value") context:boneval
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
if (prop[1] == "exportTrans") then ( transVal = RsStrtoB prop[2] ) else
|
|
if (prop[1] == "exportScale") then ( scaleVal = RsStrtoB prop[2] ) else
|
|
if (prop[1] == "exportRotation") then ( rotVal = RsStrtoB prop[2] ) else
|
|
if (prop[1] == "tag") then ( bonetag = prop[2] ) else
|
|
if (prop[1] == "exportGenericTrans") then (gentransVal = RsStrtoB prop[2] ) else
|
|
if (prop[1] == "exportVisibility") then ( visVal = RsStrtoB prop[2] )
|
|
)
|
|
)
|
|
|
|
-- AJM: Had to convert to string as there were some tags with IDs that crashed here
|
|
local doExport = undefined==bonetag or not (matchPattern (bonetag as string) pattern:"*DO_NOT_EXPORT*")
|
|
|
|
--toleranceTransVal = getuserprop boneval "exportTransTolerance"
|
|
--toleranceRotVal = getuserprop boneval "exportRotTolerance"
|
|
|
|
if blendShapeOnly == false and doExport then (
|
|
--if true then (
|
|
|
|
if transVal == true then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "translate" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "trans" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
else if gentransVal == true then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "genericTranslation" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "trans" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
if scaleVal == true then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "scale" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "scale" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
if rotVal != false then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rotate" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rot" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
if visVal == true then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "visibility0" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "visibility0" )
|
|
)
|
|
|
|
if foranim then (
|
|
for i = 0 to 7 do (
|
|
outputName = "projectData" + (i as string)
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode outputName )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode outputName )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
for childobj in boneval.children do (
|
|
|
|
local retval = RsCreateSpecFileRecFromArray childobj specfile blendShapeOnly foranim formap
|
|
if not retval do return false
|
|
)
|
|
true
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileRecNewFromArray boneroot filename bArray blendShapeOnly foranim formap = (
|
|
|
|
boneArray = bArray
|
|
XMLDoc = XmlDocument()
|
|
XMLDoc.init()
|
|
elmntRoot = XMLDoc.createelement "rage__AnimExportCtrlSpec"
|
|
XMLDoc.document.AppendChild elmntRoot
|
|
elmntTrackSpecs = XMLDoc.createelement "TrackSpecs" appendTo:elmntRoot
|
|
|
|
local retval = RsCreateSpecFileRecFromArray boneroot specfile blendShapeOnly foranim formap
|
|
if not retval do return false
|
|
|
|
XMLDoc.save (filename)
|
|
|
|
true
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileNewFromArray boneroot filename bArray blendShapeOnly foranim formap useWildcard:true = (
|
|
|
|
boneArray = bArray
|
|
XMLDoc = XmlDocument()
|
|
XMLDoc.init()
|
|
elmntRoot = XMLDoc.createelement "rage__AnimExportCtrlSpec"
|
|
XMLDoc.document.AppendChild elmntRoot
|
|
elmntTrackSpecs = XMLDoc.createelement "TrackSpecs" appendTo:elmntRoot
|
|
|
|
if findItem boneArray boneroot != 0 then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTrackSpecs
|
|
elmntTemp = XMLDoc.createelement "nameExpr" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "root" )
|
|
elmntTemp = XMLDoc.createelement "bIncludeChildren" appendTo:elmntItem
|
|
boolAttr = XMLDoc.CreateAttribute "value"
|
|
boolAttr.value = "false"
|
|
elmntTemp.Attributes.append boolAttr
|
|
elmntTracks = XMLDoc.createelement "Tracks" appendTo:elmntItem
|
|
|
|
local transVal = getuserprop boneroot "exportTrans"
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "translate" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "trans" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rotate" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rot" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
for i = 0 to 7 do (
|
|
|
|
outputName = "projectData" + (i as string)
|
|
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode outputName )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode outputName )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
|
|
)
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
|
|
for childobj in boneroot.children do (
|
|
|
|
local retval = RsCreateSpecFileRecFromArray childobj specfile blendShapeOnly foranim formap
|
|
if not retval do return false
|
|
)
|
|
)
|
|
|
|
if useWildcard then
|
|
(
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTrackSpecs
|
|
elmntTemp = XMLDoc.createelement "nameExpr" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "*" )
|
|
elmntTemp = XMLDoc.createelement "bIncludeChildren" appendTo:elmntItem
|
|
boolAttr = XMLDoc.CreateAttribute "value"
|
|
boolAttr.value = "false"
|
|
elmntTemp.Attributes.append boolAttr
|
|
elmntTracks = XMLDoc.createelement "Tracks" appendTo:elmntItem
|
|
|
|
if blendShapeOnly == false then (
|
|
--if true then (
|
|
|
|
elmntItem = XMLDoc.createelement "Item" appendTo:elmntTracks
|
|
elmntTemp = XMLDoc.createelement "inputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rotate" )
|
|
elmntTemp = XMLDoc.createelement "outputName" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "rot" )
|
|
elmntTemp = XMLDoc.createelement "components" appendTo:elmntItem
|
|
elmntTemp.AppendChild ( XMLDoc.createTextNode "X,Y,Z" )
|
|
)
|
|
)
|
|
|
|
XMLDoc.save (filename)
|
|
|
|
true
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsCreateSpecFileFromArray boneroot filename bArray foranim:false formap:false useWildcard:true = (
|
|
|
|
return (RsCreateSpecFileNewFromArray boneroot filename bArray false foranim formap useWildcard:useWildcard)
|
|
)
|
|
|
|
fn IsValidBoneName b =
|
|
(
|
|
not (matchPattern b pattern:"*footsteps*") and
|
|
not (matchPattern b pattern:"*nub")
|
|
)
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsGetBoneListInner objnode boneList = (
|
|
|
|
if objnode == undefined then (
|
|
|
|
return 0
|
|
)
|
|
|
|
if 0!=findItem gToleratedSkelBoneTypes (classof objnode) then
|
|
(
|
|
local nameCheck = RsLowercase objnode.name
|
|
|
|
if IsValidBoneName nameCheck then
|
|
(
|
|
append boneList objnode
|
|
)
|
|
)
|
|
|
|
for childobj in objnode.children do (
|
|
|
|
RsGetBoneListInner childobj boneList
|
|
)
|
|
)
|
|
|
|
|
|
--------------------------------------------------------------
|
|
--
|
|
--------------------------------------------------------------
|
|
fn RsGetBoneList objnode boneList = (
|
|
|
|
RsGetBoneListInner objnode boneList
|
|
)
|
|
|
|
fn GetBoneListFromSkin obj boneNodeOrName:0 =
|
|
(
|
|
local ret = #()
|
|
local theSkin = obj.modifiers[#skin]
|
|
if undefined==theSkin then
|
|
return ret
|
|
max modify mode
|
|
modPanel.setCurrentObject theSkin
|
|
for i=1 to (skinOps.GetNumberBones theSkin) do
|
|
(
|
|
local boneName = skinOps.GetBoneName theSkin i 0
|
|
if not (IsValidBoneName boneName) then
|
|
continue
|
|
|
|
if (boneNodeOrName==0) then
|
|
(
|
|
local objsWithBoneName = getnodebyname boneName all:true
|
|
local validBone = objsWithBoneName[1]
|
|
if objsWithBoneName.count>1 then
|
|
print ("more than one object with bone name "+boneName+": "+objsWithBoneName as string)
|
|
if objsWithBoneName.count<1 then
|
|
append objsWithBoneName (getnodebyname boneName)
|
|
for b in objsWithBoneName where isValidNode b do
|
|
validBone = b
|
|
if isValidNode validBone then
|
|
append ret validBone
|
|
)
|
|
else
|
|
append ret boneName
|
|
)
|
|
|
|
local clothObj = obj
|
|
local simMesh = RsLodDrawable_GetSimulationModel clothObj
|
|
if undefined!=simMesh then
|
|
clothObj = simMesh
|
|
if (RsCloth.IsCloth clothObj) then
|
|
(
|
|
local clothColls = #()
|
|
RsSceneLink.getChildren linkType_ClothCollision clothObj &clothColls
|
|
for col in clothColls do
|
|
(
|
|
if undefined!=col.parent then
|
|
(
|
|
gRsUlog.LogMessage ("Appended bone "+col.parent as string+" from cloth collision "+col as string+" to skeleton")
|
|
append ret col.parent
|
|
)
|
|
)
|
|
)
|
|
|
|
return ret
|
|
)
|
|
|
|
fn RsCreateDummyAndMover charbone =
|
|
(
|
|
--Get selected Biped part
|
|
object = charbone
|
|
|
|
--get COM name
|
|
bipname = biped.getNode object #horizontal
|
|
|
|
--Delete any existing Dummy or Mover Nodes
|
|
moverNode = getnodebyname "mover" exact:true
|
|
if moverNode != undefined then delete moverNode
|
|
dummyNode = getnodebyname "Dummy01" exact:true
|
|
if dummyNode != undefined then delete dummyNode
|
|
axisNode = getnodebyname "axis_helper" exact:true
|
|
if axisNode != undefined then delete axisNode
|
|
layer = layermanager.getlayerfromname "Mover Node"
|
|
if layer != undefined then layermanager.deleteLayerByName "Mover Node"
|
|
|
|
--move slider to start
|
|
slidertime = animationrange.start
|
|
|
|
--get root bone z height
|
|
bipname.transform.controller.figureMode = true
|
|
z_height = bipname.transform[4].z
|
|
bipname.transform.controller.figureMode = false
|
|
|
|
--create Dummy node
|
|
newDummyNode = Dummy()
|
|
newDummyNode.name = "Dummy01"
|
|
newDummyNode.boxsize = [.2,.2,.2]
|
|
newDummyNode.pos = [0.0,0.0,z_height]
|
|
|
|
--parent biped to it
|
|
bipname.parent = newDummyNode
|
|
|
|
--create Mover Node
|
|
newMoverNode = Dummy()
|
|
newMoverNode.name = "mover"
|
|
newMoverNode.boxsize = [.3,.3,.3]
|
|
newMoverNode.pos = [0.0,0.0,z_height]
|
|
|
|
--create axis helper node
|
|
axis_helper = Point pos:[0,0,1] isSelected:off cross:off axistripod:on size:0.25 name:"axis_helper"
|
|
setTransformLockFlags axis_helper #all
|
|
|
|
--parent nodes correctly
|
|
newMoverNode.parent = newDummyNode
|
|
axis_helper.parent = newMoverNode
|
|
|
|
--create a new layer for Dummy and Mover nodes
|
|
layer = layermanager.newlayerfromname "Mover Node"
|
|
layer.addnode axis_helper
|
|
layer.addnode newMoverNode
|
|
layer.addnode newDummyNode
|
|
)
|
|
|
|
fn RsUpdateMover xp yp zp yaw pitch roll =
|
|
(
|
|
--check selection
|
|
if (($mover != undefined) and ($mover.name == "mover")) then
|
|
(
|
|
select $mover
|
|
|
|
dummyNode = selection[1].parent
|
|
|
|
biproot=$char.controller
|
|
|
|
for child in dummyNode.children do
|
|
(
|
|
if classof child == biped_object then biproot = child
|
|
)
|
|
|
|
biproot.transform.controller.figuremode = true
|
|
figureModeBipRot = biproot.transform as eulerAngles
|
|
figureModeBipPos = biproot.transform[4]
|
|
biproot.transform.controller.figuremode = false
|
|
|
|
--delete all the keys on the mover track
|
|
deleteKeys $.controller #allKeys
|
|
|
|
dividorLimit = (ceil (((animationrange.end.frame - animationrange.start.frame) as float) / 50)) as integer
|
|
|
|
with animate on
|
|
(
|
|
dividorCount = 0
|
|
for i = animationrange.start to animationrange.end do
|
|
(
|
|
|
|
if dividorCount == 0 then (
|
|
|
|
slidertime = i
|
|
|
|
--get position and rotation
|
|
bipPos = biped.getTransform biproot #pos
|
|
bipRot = (biped.getTransform biproot #rotation) as eulerAngles
|
|
|
|
--translate mover node
|
|
if (xp ==true) then
|
|
(
|
|
$mover.pos.x = bipPos.x
|
|
)
|
|
else
|
|
(
|
|
$mover.pos.x =0.0
|
|
)
|
|
|
|
if (yp == true) then
|
|
(
|
|
$mover.pos.y = bipPos.y
|
|
)
|
|
else
|
|
(
|
|
$mover.pos.y =0.0
|
|
)
|
|
|
|
if (zp == true) then
|
|
(
|
|
$mover.pos.z = bipPos.z
|
|
)
|
|
else
|
|
(
|
|
$mover.pos.z = figureModeBipPos.z
|
|
)
|
|
|
|
-- rotate mover node
|
|
if (pitch == true) then
|
|
(
|
|
$mover.rotation.x_rotation = 0.0
|
|
)
|
|
else
|
|
(
|
|
$mover.rotation.x_rotation=0.0
|
|
)
|
|
|
|
if (roll == true) then
|
|
(
|
|
$mover.rotation.y_rotation = 0.0
|
|
)
|
|
else
|
|
(
|
|
$mover.rotation.y_rotation = 0.0
|
|
)
|
|
|
|
if (yaw == true) then
|
|
(
|
|
$mover.rotation.z_rotation = bipRot.z + figureModeBipRot.z
|
|
)
|
|
else
|
|
(
|
|
$mover.rotation.z_rotation = 0.0
|
|
)
|
|
)
|
|
dividorCount = dividorCount + 1
|
|
if dividorCount == dividorLimit then dividorCount = 0
|
|
)
|
|
)
|
|
)
|
|
else
|
|
(
|
|
messagebox "Invalid mover"
|
|
)
|
|
)
|
|
|
|
struct sNegInterval
|
|
(
|
|
start,
|
|
end
|
|
)
|
|
|
|
fn RsGetControllerKeyRangeRec cntrl &range =
|
|
(
|
|
local allKeys = cntrl.keys
|
|
if allkeys.count>0 then
|
|
(
|
|
if allkeys[1].time < range.start then
|
|
range.start = allkeys[1].time
|
|
if allkeys[allkeys.count].time > range.end then
|
|
range.end = allkeys[allkeys.count].time
|
|
)
|
|
for dependency in refs.dependsOn cntrl where (isproperty dependency "keys") do
|
|
(
|
|
RsGetControllerKeyRangeRec dependency &range
|
|
)
|
|
)
|
|
|
|
fn RsGetControllerKeyRange obj &range =
|
|
(
|
|
for dependency in refs.dependsOn obj where (isproperty dependency "keys") do
|
|
(
|
|
RsGetControllerKeyRangeRec dependency &range
|
|
)
|
|
)
|
|
|
|
-- recurse through lists and return on first found keys...
|
|
fn HasControllerType c level:0 types:#() =
|
|
(
|
|
if undefined==c then
|
|
return false
|
|
|
|
for t in types do
|
|
(
|
|
if isKindOf c t then
|
|
(
|
|
return true
|
|
)
|
|
)
|
|
-- ins = ""
|
|
-- for d=1 to level do append ins " "
|
|
-- print (ins + (classof c) as string + ":"+ (isKindOf c Constraint) as string)
|
|
if isproperty c "count" then
|
|
(
|
|
for subc = 1 to c.count do
|
|
(
|
|
if HasControllerType c[subc] level:(level+1) types:types then
|
|
(
|
|
return true
|
|
)
|
|
)
|
|
)
|
|
for subc in (refs.dependsOn c) do
|
|
(
|
|
if HasControllerType subc level:(level+1) types:types then
|
|
return true
|
|
)
|
|
return false
|
|
) |