428 lines
14 KiB
Plaintext
Executable File
428 lines
14 KiB
Plaintext
Executable File
-- filein "rockstar/export/settings.ms" -- This is fast
|
|
|
|
-- --Figure out the project
|
|
-- theProjectRoot = RsConfigGetProjRootDir()
|
|
-- theProject = RSConfigGetProjectName()
|
|
-- theWildWest = RsConfigGetWildWestDir()
|
|
|
|
-- theProjectConfig = RsConfigGetProjBinConfigDir()
|
|
|
|
-- filein (theWildWest + "script/3dsMax/_config_files/Wildwest_header.ms")
|
|
|
|
-- filein (theWildWest + "script/3dsMax/_common_functions/FN_RSTA_Rigging.ms")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
fn RSTA_oldStyleMuscleExpression muscleMesh msMuscle =
|
|
(
|
|
-- local exposeNode = CreateExposeTransformNode target1 target2
|
|
local Handle1_X = muscleMesh.pos.controller[2][1]
|
|
local Handle1_Y = muscleMesh.pos.controller[2][2]
|
|
local Handle1_Z = muscleMesh.pos.controller[2][3]
|
|
local Handle2_X = msMuscle.localPositionX.controller
|
|
local Handle2_Y = msMuscle.localPositionY.controller
|
|
local Handle2_Z = msMuscle.localPositionZ.controller
|
|
|
|
local squashVal = msMuscle.modifiers[#Muscle_Settings].muscleAttrs.squashAndStretchMult.controller
|
|
|
|
muscleMesh.scale.controller[2][1].controller = Float_expression()
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle1_X" Handle1_X
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle1_Y" Handle1_Y
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle1_Z" Handle1_Z
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle2_X" Handle2_X
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle2_Y" Handle2_Y
|
|
muscleMesh.scale.controller[2][1].controller.AddScalarTarget "Handle2_Z" Handle2_Z
|
|
|
|
local relativeValue = length ( [Handle2_X.value,Handle2_Y.value,Handle2_Z.value] - [Handle1_X.value,Handle1_Y.value,Handle1_Z.value] )
|
|
|
|
local exprStr = "( length ( [Handle2_X,Handle2_Y,Handle2_Z] - [Handle1_X,Handle1_Y,Handle1_Z] ) ) / " + ( relativeValue as string )
|
|
muscleMesh.scale.controller[2][1].controller.setExpression exprStr
|
|
|
|
-- if ( muscleMesh.modifiers["Muscle Settings"].squashAndStretch ) then
|
|
-- (
|
|
-- for i = 2 to 3 do
|
|
-- (
|
|
|
|
muscleMesh.scale.controller[2][i].controller = Float_expression()
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle1_X" Handle1_X
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle1_Y" Handle1_Y
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle1_Z" Handle1_Z
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle2_X" Handle2_X
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle2_Y" Handle2_Y
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "Handle2_Z" Handle2_Z
|
|
|
|
muscleMesh.scale.controller[2][i].controller.AddScalarTarget "squashAndStretch" squashVal
|
|
-- local mult = target1.modifiers["Muscle Settings"].muscleAttrs["squashAndStretchMult"]
|
|
-- obj.scale.controller[2][i].controller.AddScalarTarget "Multiplier" mult
|
|
local exprStr = "(1 / ( ( length ( [Handle2_X,Handle2_Y,Handle2_Z] - [Handle1_X,Handle1_Y,Handle1_Z] ) / " + (RelativeValue as string) + " ) )) * squashAndStretch"
|
|
-- local exprStr = "1 + ( ( " + (RelativeValue as string) + " - length( [Handle2_X,Handle2_Y,Handle2_Z] - [Handle1_X,Handle1_Y,Handle1_Z] ) ) * Multiplier )"
|
|
muscleMesh.scale.controller[2][i].controller.setExpression exprStr
|
|
-- )
|
|
-- )
|
|
|
|
)
|
|
|
|
fn RSTA_addMuscleScaleExpressions markers =
|
|
(
|
|
local muscleMesh = markers[4]
|
|
local msMuscle = markers[1]
|
|
local mcMuscle = markers[3]
|
|
|
|
format ("muscleMesh: "+(muscleMesh as string)+"\n")
|
|
format ("msMuscle: "+(msMuscle as string)+"\n")
|
|
format ("mcMuscle: "+(mcMuscle as string)+"\n")
|
|
|
|
--UNTIL AUTODESK GIVE US A FIX WE HAVE TO USE THE OLD HARDCODED MUSCLES DUE TO UPDATES NEEDING KEYED OTHERWISE
|
|
|
|
RSTA_oldStyleMuscleExpression muscleMesh msMuscle
|
|
|
|
-- local Handle2_X = msMuscle.localPositionX.controller
|
|
--
|
|
-- local squashy = msMuscle.modifiers[#Muscle_Settings].muscleAttrs.squashAndStretchMult.controller
|
|
--
|
|
-- muscleMesh.scale.controller[2][1].controller = Float_expression()
|
|
--
|
|
-- local defaultDist = distance msMuscle mcMuscle
|
|
--
|
|
-- muscleMesh.scale.controller[2][1].controller.AddScalarConstant "defaultDist" defaultDist
|
|
-- muscleMesh.scale.controller[2][1].controller.AddScalarTarget "distX" Handle2_X
|
|
-- local exprStr = ("( 1 / defaultDist) * distX")
|
|
|
|
-- muscleMesh.scale.controller[2][1].controller.setExpression exprStr
|
|
--
|
|
-- muscleMesh.scale.controller[2][2].controller = Float_expression()
|
|
-- muscleMesh.scale.controller[2][3].controller = Float_expression()
|
|
-- muscleMesh.scale.controller[2][2].controller.AddScalarConstant "defaultDist" defaultDist
|
|
-- muscleMesh.scale.controller[2][3].controller.AddScalarConstant "defaultDist" defaultDist
|
|
-- muscleMesh.scale.controller[2][2].controller.AddScalarTarget "distX" Handle2_X
|
|
-- muscleMesh.scale.controller[2][3].controller.AddScalarTarget "distX" Handle2_X
|
|
--
|
|
-- muscleMesh.scale.controller[2][2].controller.AddScalarTarget "squashAndStretch" squashy
|
|
-- muscleMesh.scale.controller[2][3].controller.AddScalarTarget "squashAndStretch" squashy
|
|
--
|
|
-- local exprStr = ("if\n(\n\tsquashAndStretch = 0,\n\t1,\n\t((1 - (1 / defaultDist) * distX) + 1) * squashAndStretch\n)")
|
|
-- muscleMesh.scale.controller[2][2].controller.setExpression exprStr
|
|
-- muscleMesh.scale.controller[2][3].controller.setExpression exprStr
|
|
|
|
if ( msMuscle.modifiers["Muscle Settings"].useRSSpring ) then
|
|
(
|
|
local RsSprg = muscleMesh.position.controller[#Available].controller = (RsSpring ())
|
|
RsSprg.xLimitMin = -0.001
|
|
RsSprg.yLimitMin = -0.001
|
|
RsSprg.zLimitMin = -0.001
|
|
RsSprg.xLimitMax = 0.001
|
|
RsSprg.yLimitMax = 0.001
|
|
RsSprg.zLimitMax = 0.001
|
|
)
|
|
)
|
|
|
|
fn rsta_addMuscleSettingsAttributes markers markerSquashVal =
|
|
(
|
|
local msMuscle = markers[1]
|
|
local meMuscle = markers[2]
|
|
|
|
muscleMainDef = attributes muscleAttrs
|
|
(
|
|
parameters markerP rollout:markerR
|
|
(
|
|
squashAndStretchMult type:#float ui:spn_squashAndStretchMult default:1
|
|
useRSSpring type:#boolean ui:cbx_useRSSpring
|
|
)
|
|
|
|
rollout markerR "Marker Attributes"
|
|
(
|
|
spinner spn_squashAndStretchMult "Squash and Stretch" align:#right fieldWidth:30 range:[ 0, 20, 1 ]
|
|
checkBox cbx_useRSSpring "RS Spring"
|
|
|
|
on spn_squashAndStretchMult changed arg do
|
|
(
|
|
squashAndStretchMult = arg
|
|
)
|
|
|
|
on cbx_useRSSpring changed arg do
|
|
(
|
|
useRSSpring = arg
|
|
)
|
|
)
|
|
)
|
|
|
|
local aHMod = EmptyModifier()
|
|
aHMod.name = "Muscle Settings"
|
|
addModifier msMuscle aHMod
|
|
custAttributes.add aHMod muscleMainDef
|
|
|
|
--now we need to add a bezier controller to the squash attr
|
|
msMuscle.modifiers[#Muscle_Settings].muscleAttrs.squashAndStretchMult.controller = bezier_float ()
|
|
|
|
if markerSquashVal != undefined do
|
|
(
|
|
msMuscle.modifiers[#Muscle_Settings].muscleAttrs.squashAndStretchMult = markerSquashVal
|
|
)
|
|
)
|
|
|
|
|
|
|
|
fn rsta_addMuscleMarkerSettingsAttributes marker markerSquashVal =
|
|
(
|
|
muscleMarkerMainDef = attributes muscleMarkerAttrs
|
|
(
|
|
parameters markerP rollout:markerR
|
|
(
|
|
squashAndStretchVal type:#float ui:spn_squashAndStretchVal default:1
|
|
)
|
|
|
|
rollout markerR "Marker Attributes"
|
|
(
|
|
spinner spn_squashAndStretchVal "Squash and Stretch" align:#right fieldWidth:30 range:[ 0, 20, 1 ]
|
|
|
|
on spn_squashAndStretchVal changed arg do
|
|
(
|
|
squashAndStretchVal = arg
|
|
)
|
|
)
|
|
)
|
|
|
|
local modExistsAlready = false
|
|
|
|
for m = 1 to marker.modifiers.count do
|
|
(
|
|
if marker.modifiers[m].name == "muscleMarker Settings" do
|
|
(
|
|
modExistsAlready = true
|
|
)
|
|
)
|
|
|
|
if modExistsAlready == false do
|
|
(
|
|
local aHMod = EmptyModifier()
|
|
aHMod.name = "muscleMarker Settings"
|
|
addModifier marker aHMod
|
|
custAttributes.add aHMod muscleMarkerMainDef
|
|
|
|
--now we need to add a bezier controller to the squash attr
|
|
marker.modifiers[#muscleMarker_Settings].muscleMarkerAttrs.squashAndStretchVal.controller = bezier_float ()
|
|
)
|
|
|
|
if markerSquashVal != undefined do
|
|
(
|
|
marker.modifiers[#muscleMarker_Settings].muscleMarkerAttrs.squashAndStretchVal = markerSquashVal
|
|
)
|
|
|
|
|
|
)
|
|
|
|
-- fn rsta_makeMuscleMesh msMuscle =
|
|
fn rsta_makeMuscleMesh muscleNodes =
|
|
(
|
|
local msMuscle = muscleNodes[1]
|
|
local meMuscle = muscleNodes[2]
|
|
-- meMuscle = getNodeByName ("ME_"+(substring msMuscle.name 4 -1))
|
|
|
|
local mcName = substituteString msMuscle.name "_MS_" "_MC_"
|
|
local mbName = substituteString msMuscle.name "_MS_" "_MB_"
|
|
|
|
|
|
-- mcMuscle = point pos:meMuscle.position isSelected:on name:("MC_"+(substring msMuscle.name 4 -1)) size:0.05 centerMarker:false axisTripod:false cross:true box:false constantScreenSize:false drawontop:false
|
|
mcMuscle = point pos:meMuscle.position isSelected:on name:mcName size:0.05 centerMarker:false axisTripod:false cross:true box:false constantScreenSize:false drawontop:false
|
|
|
|
mcMuscle.transform = meMuscle.transform
|
|
|
|
mcMuscle.parent = msMuscle
|
|
msMuscle.exposeNode = mcMuscle
|
|
|
|
select mcMuscle
|
|
rsta_FreezeTransform()
|
|
|
|
RSTA_createPosConstraint mcMuscle meMuscle
|
|
|
|
--now we can build the muscle geo
|
|
local markers = #(msMuscle,meMuscle,mcMuscle)
|
|
|
|
local rad = 0.03
|
|
|
|
local mStart = markers[1]
|
|
local mEnd = markers[2]
|
|
|
|
local tempTForm = mStart.transform
|
|
tempTForm.pos = mEnd.pos
|
|
|
|
local fwdVec = mEnd.pos - mStart.pos
|
|
local midPoint = ( ( length fwdVec ) / 2 )
|
|
local normVec = normalize fwdVec
|
|
|
|
local worldVec = [0,0,1]
|
|
local sideVec = normalize( cross normVec worldVec )
|
|
local upVec = normalize( cross normVec sideVec )
|
|
|
|
local muscMatrix = matrix3 normVec sideVec upVec mStart.pos
|
|
|
|
local muscMesh = sphere()
|
|
muscMesh.radius = rad
|
|
muscMesh.segments = 16
|
|
-- local muscName = trimLeft mStart.name "MS"
|
|
-- muscName = "MB" + muscName
|
|
-- muscMesh.name = muscName
|
|
muscMesh.name = mbName
|
|
muscMesh.wirecolor = (color 224 86 86)
|
|
muscMesh.rotation = ( quat 0 1 0 1 )
|
|
resetXForm muscMesh
|
|
convertToMesh muscMesh
|
|
|
|
muscMesh.transform = muscMatrix
|
|
in coordsys local( muscMesh.pos.x += midPoint )
|
|
|
|
select muscMesh
|
|
setCommandPanelTaskMode #modify
|
|
subObjectLevel = 1
|
|
|
|
meshop.setSoftSel muscMesh true
|
|
meshop.setFalloff muscMesh 0.08
|
|
meshop.setSSUseEdgeDist muscMesh true
|
|
meshop.setSSEdgeDist muscMesh 3
|
|
update muscMesh
|
|
|
|
local offsetVal = midPoint - rad
|
|
|
|
muscMesh.selectedVerts = #{1}
|
|
meshop.moveVert muscMesh.mesh #all [offsetVal,0,0] node:muscMesh.mesh useSoftSel:true
|
|
|
|
muscMesh.selectedVerts = #{muscMesh.verts.count}
|
|
meshop.moveVert muscMesh.mesh #all [-offsetVal,0,0] node:muscMesh.mesh useSoftSel:true
|
|
|
|
muscMesh.pivot = muscMesh.verts[muscMesh.verts.count].pos
|
|
muscMesh.parent = mStart
|
|
|
|
subObjectLevel = 0
|
|
|
|
select muscMesh
|
|
rsta_FreezeTransform()
|
|
|
|
append markers muscMesh
|
|
|
|
RSTA_addMuscleScaleExpressions markers
|
|
|
|
for x in markers do
|
|
(
|
|
if ( matchPattern x.name pattern:"MS_*" ) then
|
|
(
|
|
tag = ("exportTrans = false" + "\r\n" + "translateTrackType=TRACK_BONE_TRANSLATION" + "\r\n" + "exportRot = true")
|
|
setUserPropBuffer x tag
|
|
)
|
|
else if ( matchPattern x.name pattern:"ME_*" ) then
|
|
(
|
|
tag = ("exportTrans=true\r\ntranslateTrackType=TRACK_BONE_TRANSLATION")
|
|
setUserPropBuffer x tag
|
|
)
|
|
else if ( matchPattern x.name pattern:"MB_*" ) then
|
|
(
|
|
tag = "exportScale = true"
|
|
setUserPropBuffer x tag
|
|
)
|
|
)
|
|
)
|
|
|
|
fn RSTA_createMuscleSystem index parNode chiNode nodeNames =
|
|
(
|
|
/**
|
|
|
|
index PARAM IS THE NUMBER WE WANT TO ADD TO THE MUSCLE SYSTEM
|
|
posNode IS AN ABOJECT WE WANT TO USE AS SOURCEPOSITION
|
|
WILL CREATE 3 NODES FIRST OF ALL
|
|
1) MS_Muscle -- A EXPOSE TRANSFORM HELPER THIS WILL GET PARENTED BY USER THIS IS THE START
|
|
2) ME_Muscle --AN END NODE WHICH GETS PARENTED BY USER. THIS IS THE END
|
|
3) MC_Muscle --A CONSTRAINED NODE. THIS IS A CHILD OF (1) AND IS POSITION CONSTRAINED TO (2) . THIS IS USED TO TRACK THE DISTANCES BETWEEN 1 AND 2
|
|
*/
|
|
|
|
local ind = ""
|
|
if index != -1 then
|
|
(
|
|
ind = index as string
|
|
)
|
|
|
|
msName = ("Muscle_MS_"+(ind as string))
|
|
meName = ("Muscle_ME_"+(ind as string))
|
|
|
|
if nodeNames != undefined do
|
|
(
|
|
msName = nodeNames[1]
|
|
meName = nodeNames[2]
|
|
)
|
|
|
|
markerSquashVal = 1.0
|
|
|
|
-- if parNode.
|
|
|
|
msMuscle = ExposeTm pos:parNode.position isSelected:on name:msName size:0.05 centerMarker:false axisTripod:false cross:true box:false constantScreenSize:false drawontop:false
|
|
meMuscle = point pos:chiNode.position isSelected:on name:meName size:0.05 centerMarker:false axisTripod:false cross:false box:true constantScreenSize:false drawontop:false
|
|
|
|
msMuscle.wirecolor = color 228 184 152
|
|
meMuscle.wirecolor = color 228 184 152
|
|
|
|
format ("parNode: "+(parNode.name)+"\n")
|
|
format ("chiNode: "+(chiNode.name)+"\n")
|
|
format ("msMuscle: "+(msMuscle.name)+"\n")
|
|
format ("meMuscle: "+(meMuscle.name)+"\n")
|
|
|
|
msMuscle.transform = parNode.transform
|
|
meMuscle.transform = chiNode.transform
|
|
|
|
msParName = (substring parNode.parent.name 8 -1)
|
|
|
|
format ("Attempting to parent "+msMuscle.name+" to "+msParName+"\n")
|
|
|
|
msParNode = (getNodeByName msParName)
|
|
if msParNode == undefined do (break())
|
|
msMuscle.parent = msParNode
|
|
|
|
|
|
meParName = (substring chiNode.parent.name 8 -1)
|
|
format ("Attempting to parent "+meMuscle.name+" to "+meParName+"\n")
|
|
meParNode = getNodeByName meParName
|
|
if meParNode == undefined do (break())
|
|
meMuscle.parent = meParNode
|
|
|
|
select msMuscle
|
|
rsta_FreezeTransform()
|
|
|
|
select meMuscle
|
|
rsta_FreezeTransform()
|
|
|
|
markerSquashVal = 1.0
|
|
|
|
if parNode.modifiers[#muscleMarker_Settings] != undefined do
|
|
(
|
|
markerSquashVal = parNode.modifiers[#muscleMarker_Settings].muscleMarkerAttrs.squashAndStretchVal
|
|
)
|
|
|
|
rsta_addMuscleSettingsAttributes #(msMuscle, meMuscle) markerSquashVal
|
|
--now we need to put a lookat on msMuscle
|
|
|
|
RSTA_createAimConstraint msMuscle meMuscle meMuscle.parent
|
|
msMuscle.rotation.controller[#LookAt_Constraint].upnode_world = false
|
|
msMuscle.rotation.controller[#LookAt_Constraint].upNodeAxis = 0
|
|
|
|
select meMuscle
|
|
|
|
--now we need to get the user to position this shit!
|
|
|
|
|
|
if msMuscle.position != parNode.position do
|
|
(
|
|
format (msMuscle.name+" in wrong place!\n")
|
|
)
|
|
if meMuscle.position != chiNode.position do
|
|
(
|
|
format (meMuscle.name+" in wrong place!\n")
|
|
)
|
|
|
|
madeMuscleNodes = #(msMuscle, meMuscle)
|
|
|
|
return madeMuscleNodes
|
|
)
|