serguei-k

// Macros
#define PARALLEL_FOR_BEGIN(type, variable, first, last, step) \
    tbb::parallel_for(first, last, step, [&] (type variable)

#define PARALLEL_FOR_END );

// Example usage
PARALLEL_FOR_BEGIN(unsigned, index, 0u, count, 1u) {
    // inner loop code
} PARALLEL_FOR_END

serguei-k

global proc AEFastExpression(string $nodeName)
{
    editorTemplate -addControl "expression";
}

serguei-k

global proc AEFastExpression(string $nodeName)
{
    editorTemplate -callCustom "CreateCustomControl" "UpdateCustomControl" "expression";
}

global proc CreateCustomControl(string $attrName)
{
    // command to create custom control
}

serguei-k

// ExpressionControlCommand.h
#pragma once
#include <maya/MPxCommand.h>

class ExpressionControlCommand : public MPxCommand
{
public:
    MStatus doIt(const MArgList& argList) override;
    bool isUndoable() const override;

serguei-k

global proc CreateCustomControl(string $attrName)
{
    expressionControl -a $attrName -l "Expression" "expressionControl";
}

global proc UpdateCustomControl(string $attrName)
{
    expressionControl -e -a $attrName "expressionControl";
}

serguei-k

MVector translationAverage(const std::vector<MVector>& values)
{
    if (values.empty()) return MVector::zero;
    const MVector sum = std::accumulate(values.begin(), values.end(), MVector::zero);
    return sum / values.size();
}

serguei-k

MVector scaleAverage(const std::vector<MVector>& values)
{
    if (values.empty()) return MVector::zero;
    const MVector sum = std::accumulate(values.begin(), values.end(), MVector::zero,
                                        [](const MVector& a, const MVector& b)
                                        {
                                            // assumes [Vx, Vy, Vz] > 0
                                            return MVector(a.x + std::log(b.x), a.y + std::log(b.y), a.z + std::log(b.z));
                                        });
    const MVector average = sum / values.length();

serguei-k

MEulerRotation rotationAverage(const std::vector<MQuaternion>& values)
{
    if (values.empty()) return MEulerRotation::identity;
    const MQuaternion sum = std::accumulate(values.begin(), values.end(), MQuaternion::identity,
                                            [](const MQuaternion& a, const MQuaternion& b)
                                            {
                                                return a + b.log();
                                            });
    const MQuaternion average(sum.x / values.size(), sum.y / values.size(), sum.z / values.size(), sum.w / values.size());
    return average.exp().asEulerRotation();

serguei-k

float $rate = 3.14 / 2.0;
float $theta = offset.translateX * $rate + control.translateX * $rate;
float $phi = offset.translateY * $rate - control.translateY * $rate;

constraint.translateX = sin($theta) * sin($phi);
constraint.translateY = cos($phi);
constraint.translateZ = cos($theta) * sin($phi);

serguei-k

import maya.api.OpenMaya as om
from math import *

for i, p in enumerate(cmds.ls('unit.vtx[*]', fl=True)):
    x, y, z = cmds.xform(p, q=True, t=True)
    proj = om.MVector(x / (1 - z), y / (1 - z), 0)
    cmds.xform('unit.vtx[{0}]'.format(i), t=proj)