Question

我要实现的目标是在Maya中进行棘轮操纵。现在，我有一个控制器，其极限旋转X值介于0-55之间。我在控制器和棘轮的旋转Z之间创建了一个从动钥匙，因此，当驾驶员为0时，从动为0；当驾驶员为55时，从动为60，中间还有一些钥匙。我想要的是，当动画师将驱动程序设置为55时，驱动程序必须设置为60，直到现在一切都很好，但是当动画师将驱动程序的值重新设置为0时，我希望驱动程序n的值保持在60。因此，当驾驶员再次转到55时，驾驶员将转到120，依此类推。重复此步骤直到棘轮旋转到360。我唯一要做的就是创建一个长属性，其值介于0-336之间，所有事件都立即发生。因此，动画师无需将驱动程序重新设置为0。但这很令人困惑。我知道驱动键是映射值，因此这是不可避免的，但是我该怎么做呢？我需要动画节点停止的python脚本节点？然后重新开始

所以我试图编写一个将在scriptNode中的函数，以便每次动画师将值放在锤子的turnX上时都将运行。从0-> 55开始工作，但是我陷入了必须将值从55-> 0降低的问题。

import maya.cmds as mc
def hammer_C():
RX = mc.getAttr(‘hammer.rotateX’)
RZ = mc.getAttr(‘cylider.rotateZ’)
if RX > 0:
   mc.setAttr(‘cylider.rotateZ’, -RX )
elif RX < 55:
   mc.setAttr(‘cylider.rotateZ’, RZ )
else:
   print ‘TEST’

所以基本上，我想知道Python中是否有一种方法可以说：当value_A从0变为55时，而当value_A从55变为0时又做了其他事情

Answer 1

我不认识玛雅人，但我想我了解您的需求，您正在尝试对ratchet device进行建模，并且通过55或60或360进行建模当前旋转角度（以度为单位）。

enter image description here

我还希望您需要将棘轮锁定在每个60度，这意味着一旦达到60度的角度倍数，就应锁定该棘轮，以防止其向后退到该角度以下。在60的两个倍数之间，它可能会前进和后退。

因此，我建议使用下一个代码，它不是特定于Maya的代码，但仍然可以使您知道该怎么做并可以应用于您的情况。我们可以从此代码开始，并在需要时进行改进。

我了解到您不太了解python，为此，我还用can also try online（加上接受）的单行公式（next_driven_angle的计算）创建了非常小的代码最后version with maya）：

import math
previous_driver_angle = 0.
previous_driven_angle = 0.
for next_driver_angle in [0, 10, 25, 35, 55, 35, 45]:
    next_driven_angle = max(math.floor(previous_driven_angle / 60. + 10 ** -6) * 60., previous_driven_angle + (next_driver_angle - previous_driver_angle) * 60. / 55.)
    print('driver', next_driver_angle, 'driven', next_driven_angle)
    previous_driver_angle = next_driver_angle
    previous_driven_angle = next_driven_angle

上面这段小代码的输出是：

driver 0 driven 0.0
driver 10 driven 10.909090909090908
driver 25 driven 27.272727272727273
driver 35 driven 38.18181818181818
driver 55 driven 60.0
driver 35 driven 60.0
driver 45 driven 70.9090909090909

模拟棘轮随机过程的下一个大代码（在下面列出）的输出：

  0: driver   0.0 driven   0.0 non-locked |   1: driver -33.8 driven   0.0     locked |
  2: driver -17.0 driven  18.4 non-locked |   3: driver   3.5 driven  40.7 non-locked |
  4: driver  34.8 driven  74.9 non-locked |   5: driver  53.9 driven  95.7 non-locked |
  6: driver  90.2 driven 135.3 non-locked |   7: driver  79.0 driven 123.0 non-locked |
  8: driver 103.7 driven 150.0 non-locked |   9: driver  67.3 driven 120.0     locked |
 10: driver  34.9 driven 120.0     locked |  11: driver  22.5 driven 120.0     locked |
 12: driver -13.5 driven 120.0     locked |  13: driver   5.4 driven 140.6 non-locked |
 14: driver -11.9 driven 121.7 non-locked |  15: driver -48.5 driven 120.0     locked |
 16: driver -67.5 driven 120.0     locked |  17: driver -78.0 driven 120.0     locked |
 18: driver -56.0 driven 143.9 non-locked |  19: driver -27.2 driven 175.3 non-locked |
 20: driver -60.2 driven 139.4 non-locked |  21: driver -60.2 driven 139.4 non-locked |
 22: driver -25.5 driven 177.3 non-locked |  23: driver -38.5 driven 163.1 non-locked |
 24: driver -30.8 driven 171.4 non-locked |  25: driver -40.4 driven 161.0 non-locked |
 26: driver  -8.3 driven 196.0 non-locked |  27: driver  -5.0 driven 199.6 non-locked |
 28: driver -25.4 driven 180.0     locked |  29: driver -21.0 driven 184.8 non-locked |
 30: driver   7.3 driven 215.6 non-locked |  31: driver  39.9 driven 251.1 non-locked |
 32: driver   1.3 driven 240.0     locked |  33: driver  24.8 driven 265.6 non-locked |
 34: driver  48.7 driven 291.7 non-locked |  35: driver  71.7 driven 316.8 non-locked |
 36: driver  79.3 driven 325.0 non-locked |  37: driver  54.7 driven 300.0     locked |
 38: driver  73.8 driven 320.8 non-locked |  39: driver  43.5 driven 300.0     locked |
 40: driver   6.6 driven 300.0     locked |  41: driver -29.4 driven 300.0     locked |
 42: driver  -7.7 driven 323.6 non-locked |  43: driver  20.5 driven 354.4 non-locked |
 44: driver -12.0 driven 318.9 non-locked |  45: driver  23.8 driven 358.0 non-locked |
 46: driver  61.8 driven 399.4 non-locked |

下一个代码也可以是run online here。

def Main():
    import math, random, sys

    driven_lock_angle_step = 60.
    driver_to_driven_ratio = 55. / driven_lock_angle_step
    driver_angle = 0.
    driven_angle = 0.

    def SetDriverAngle(new_driver_angle):
        nonlocal driver_angle, driven_angle
        
        driver_angle_delta = new_driver_angle - driver_angle
        driven_angle_delta = driver_angle_delta / driver_to_driven_ratio
        
        nearest_driven_lock_angle = math.floor(driven_angle / driven_lock_angle_step + 10 ** -6) * driven_lock_angle_step
        
        driven_was_locked = driven_angle + driven_angle_delta < nearest_driven_lock_angle
        driven_angle = max(nearest_driven_lock_angle, driven_angle + driven_angle_delta)
        driver_angle += driver_angle_delta
        
        return driven_was_locked
        
    # Emulate Process
    
    forward_prob = 0.6 # Probability of forward move, backward move probability will be 1 - forward_prob
    max_step = 40 # Maximum random jump to do
    max_possible_steps = 1000
    driven_stop_angle = 360.
    outputs_per_line = 2 # Entries per line when printing text
    
    was_locked = False
    random.seed(0)
    for i in range(max_possible_steps):
        sys.stdout.write(
            f'{str(i).rjust(3)}: driver {str(round(driver_angle, 1)).rjust(5)} ' +
            f'driven {str(round(driven_angle, 1)).rjust(5)} ' +
            f'{("locked" if was_locked else "non-locked").rjust(10)} | '
        )
        if (i + 1) % outputs_per_line == 0 or i + 1 >= max_possible_steps or driven_angle >= driven_stop_angle:
            sys.stdout.write('\n')
        if driven_angle >= driven_stop_angle:
            break
        driver_angle_delta = random.random() * max_step * (1. if random.random() < forward_prob else -1.)
        was_locked = SetDriverAngle(driver_angle + driver_angle_delta)
    
Main()

在Maya中，我可以阻止读取动画曲线节点吗？

1 个答案: