It would be useful to have a basic DG node type with no attributes or behavior.   Scripts could use this to store arbitrary data, for things like settings that should be saved to the scene.   Another use came up recently here, where you want an empty node to just hold a rig attribute: https://forums.autodesk.com/t5/maya-programming/does-a-math-round-or-floor-node-exist-in-maya/m-p/8919889#M10138   Using existing nodes isn't great, because they all have existing semantics and attributes.  Using a dummy multiplyDivide is confusing, since it has nothing to do with the multiplyDivide node.  Empty transforms aren't appropriate either (clutters the scene with DAG nodes), and they also have a ton of unneeded attributes.  https://forum.highend3d.com/t/creating-a-empty-node/6428 suggests using an unknown node, which I think is a bad idea as well, since the existence of unknown nodes in a scene indicates that there are missing plugins.   I've used a custom node for this, but usually adding a plugin dependency for this isn't wanted (that's worse than repurposing an existing node).   A simple node type named "node" with no extra attributes would be a simple solution.  It might have a single "nodeType" string attribute, for scripts to identify their node to find it later (usually I add an attribute for this, but it would standardize identifying the nodes, could be used by the node editor for display, etc).     Show More

I've scripted the creation of attributes just so I can quickly see the data I want in the channelBox.  For instance, distanceBetween...I had to create an "outDistance" attribute and connect it to the "distance" attribute to see the value in the channelBox.  But when I delete source objects to the distanceBetween node, it won't delete because it has a connection to itself.  A lot of nodes can end up just hanging out in your scene, all because dummy attributes have to be made to see the data. Show More

Exactly how 2D shape tween works in Adobe Animate but for 3D models. Could be useful to show a model process for example, a cube being transformed into a skyscraper by animating the models inbetween the modelling process, kind of like Zbrush saving the modelling process. Could also be used as automatic/AI blendshapes. Show More

I would like to request from maya team to bring some new features like anime style and crease pencil update like blender.   Show More

about Vulkan description... Vulkan can provide more Performance GPU acceleration than the DirectX11 DirectX12. Blender is implementing Vulkan. Show More

For some reason, we have to enter the rotates in cmds.rotate as '150deg' or something similar. Why? It would make more sense to me if we put in a number instead of a string and have an additional variable that sets it to degrees, radians, etc. This whole 'have to enter a number and string' thing is really unintuitive, since it's like the only commonly used function that does it Show More

I want a way to obfuscate MEL or Python scripts. I usually develop with MEL scripts, but I'm worried that the source code can be read by anyone. Without this, we run into big problems when we sell scripts or when we temporarily provide tools to external companies. I can hide the code using C ++, but it's difficult for beginners like me. I've heard that 3dsMax has a simple scripting method for obfuscation, but I hope Autodesk can offer some new solutions in Maya as well. For that matter, Autodesk should create a mechanism similar to Apple's App Store. Not only will you be able to obfuscate your code, but Autodesk should also be able to profit from selling your assets. Please consider this. Show More

The Python buffer protocol allows for fast reading/writing of underlying numeric data. If we try to convert, say, a skin weight array into something that python (or more importantly numpy) can understand, for a moderately sized model, that takes 17 seconds of just copying data, and that. just. sucks.   And It could be as simple as adding a .toBuffer() or .toBytes() method on any numeric OpenMaya.M*Array objects. They could return a copy of the data as a flattened (for MPoint/MVector/MQuaternion/etc) array.array or bytestring object. Then it's easy to re-interpret that data as whatever we need.   Show More

It would be super handy if the "output" of the script editor was searchable.  ( yes i know you can copy and paste the output into the "input" section of the script editor, and then search that, but there are many bug fixing moments, where just searching the "output" ( upper section) would be very welcome )   -=s Show More

This is not in Maya for some reason and has not been added yet but Max has had it for many years. On top of that, other software does this with no problems, ex Substance designer and painter, nuke, zbrush.   It is a no brainier, for every Maya scene, when you set the project the data sticks and stay with each individual scene. Instead of what you have now where you set a project and that set location applies to all new scenes. This is an annoyance for any production artist who is working on multiple task and are having to constantly set their project paths each time they open another scene.         Show More

make the normalize node have n inputs and n outputs.   At first we were exited to find the normalize 2024 node, but then we saw it is just a vector normalize (3 inputs). We already had quad normalize and vector product (normalize checkbox), so this node brings nothing new to the table. We need a node for large amounts of inputs like weights or more complex situations (ie. rigging).   Please expand or make a new node (ie. n-normalize) having many in- and outputs map to each other. This should be across the board for all math nodes dimensionality should not be a limiting factor for basic math nodes.   please include a switch for various types like i.e. :  Min-Max Normalization (Rescaling): normalized_value = (value - min_value) / (max_value - min_value) Goal: Rescale the values within a specific range, typically between 0 and 1. Explanation: This formula linearly transforms the values based on the minimum and maximum values in the dataset. It ensures that the minimum value is mapped to 0 and the maximum value is mapped to 1, with other values scaled proportionally in between. Z-Score Normalization (Standardization): normalized_value = (value - mean) / standard_deviation Goal: Standardize the values to have a mean of 0 and a standard deviation of 1. Explanation: This formula standardizes the values by subtracting the mean and dividing by the standard deviation. It helps in comparing values across different distributions and identifies how many standard deviations a value is away from the mean. Decimal Scaling Normalization: normalized_value = value / 10^d (where d is the number of decimal places to shift) Goal: Shift the decimal places of the values to achieve normalization. Explanation: This formula divides the values by a power of 10, shifting the decimal places. The number of decimal places to shift depends on the maximum value in the dataset. It simplifies calculations and maintains the relative order of values. Log Transformation: normalized_value = log(value) Goal: Transform the values using logarithmic scaling. Explanation: This formula applies a logarithmic function to the values. It compresses the range of large values, emphasizing smaller differences. It is useful when dealing with skewed data or when the ratio between values matters more than the absolute difference. Sigmoidal Transformation: normalized_value = 1 / (1 + exp(-value)) Goal: Map the values to a bounded range between 0 and 1 using a sigmoid function. Explanation: This formula uses the sigmoid function to map values to the interval (0, 1). It compresses extreme values towards the upper and lower bounds while preserving the order of values. It is commonly used in machine learning for classification tasks. Softmax Transformation: normalized_value = exp(value) / sum(exp(all_values)) Goal: Normalize a set of values into a probability distribution. Explanation: This formula exponentiates each value and divides it by the sum of exponentiated values across the dataset. It ensures that the resulting values sum up to 1, making them interpretable as probabilities. It is commonly used in multi-class classification problems. Unit Vector Normalization (Vector Normalization or Euclidean Normalization): normalized_value = value / sqrt(sum(value^2)) Goal: Scale vectors to have a length (magnitude) of 1. Explanation: This formula divides each value by the Euclidean norm (magnitude) of the vector. It normalizes the vector to have a constant length, making it independent of the scale. It is useful in machine learning algorithms that rely on distance calculations. Pareto Scaling (Square Root Transformation or Square Root Scaling): normalized_value = sqrt(value) Goal: Normalize values by taking the square root. Explanation: This formula applies the square root function to the values. It reduces the impact of large values while preserving the relative order of values. It is useful when dealing with data that has a wide range of magnitudes.   Median-MAD Normalization (Median Absolute Deviation): normalized_value = (value - median) / median_absolute_deviation Goal: Normalize values by using the median and median absolute deviation. Explanation: This formula subtracts the median from each value and divides it by the median absolute deviation (MAD). It provides robust normalization by considering the central tendency and spread of the data. It is helpful when dealing with outliers or non-normally distributed data. Thank you. - Tristan Show More

Currently maya doesn't support the standard python multiprocessing module (on Windows, anyway).  It must be something to to with an interaction between what maya sets for the sys.executable and sys.prefix variables and perhaps the fact that Maya the application won't take a python file as an argument.  The upshot is that you have to do some ugly workarounds like saving temporary files and launching separate Mayapy instances to handle distributed processing. It'd be really handy for a lot of pipeline work to be able to use vanilla python multiporocessing to paralleliize big tasks. Show More

Since Maya introduced official support for UDIM uv tiling Maya internally has a procedure for expanding a UDIM expression in a path to a list of files. This procedure slows down Maya's interactivity immensely when working with File nodes in the attribute editor and the Hypershade. It also slows down dependency queries.   After many hours of debugging some severe interactivity performance problems we were having with Maya on a production asset we narrowed down the source of these problems to this expansion function.   Maya/Python/Lib/site-packages/maya/app/general/fileTexturePathResolver.py - findAllFilesForPattern   This expansion function is not written in the most efficient manner. On the asset in question we had a single directory with around 1600 texture files. If you look at the way this function works you will quickly discover that the performance of this routine degrades severely when the size of the directory increases due to it's "os.path.isfile" check before the the re.match.   We have "monkey patched" our maya deployment to improve the performance of this function. With our changes we reduced a cmds.file(q=True, l=True) dependency query down from 3m-10m to 5-10s.  We also noticed that when selecting file nodes it calls this function (likely to draw the UI controls on the file node). That's not surprising, but what is surprising is it appears to call this function twice. Doubling the expensive IO call. Selecting file nodes in this asset would lockup maya for about 10s. Now the lockup is hardly noticeable.   I have two suggestions. 1. At the very least, reverse the os.path.isfile and re.match calls in findAllFilesForPattern. Simply reversing them provides equivalent functionality with massive performance improvements. 2. Better yet, take advantage of python's os.scandir (new to python3, but there is a 3rd party backport to 2.7) which removes the need for the separate os.path.isfile call. Show More

in unreal Engine you can work with 'component' jaw pitch and roll witch acts pretty much like the 'object' or  'local' rotation mode in maya when rotating an object with the gizmo. Adding or subtracting rotations will not result in gimbal locks and convert to euler behind the screens, this will be more straight forward for rigging.   Please add some native nodes that can return the component jaw pitch and roll which you can convert to quats, euler (rotation order), matrix etc. and vise versa.    This should make twist calculations more easy to implement and rigging more fun.  The roll of your wrist will then be the simple twist amount of your twist joints in the arm, very easy to implement.   lets say a shoulder corrective, a few nodes to negate the arm roll and do a - 50 % of pitch and yaw.    Also please implement a simple arc, cos, tan, etc  node. this is a very basic math node that is missing. look here (https://www.chadvernon.com/blog/trig-maya/) at how ridiculously complex this is to make something as simple as that.   Also make commands for this in cmds.xform  to get the roll jaw and pitch   also see https://vaishakp.com/2018/05/28/angle-extractor-in-maya/ https://vimeo.com/122797330 https://apps.autodesk.com/MAYA/en/Detail/Index?id=1642215970322859153&appLang=en&os=Win64 thank you   Tristan   Show More