✨🎯 𝘿𝙖𝙮13 -100-𝘿𝙖𝙮𝙨 𝘾𝙤𝙙𝙚 𝘾𝙝𝙖𝙡𝙡𝙚𝙣𝙜𝙚 🚀🎨

import maya.cmds as cmds

import maya.api.OpenMaya as om

import random

def scatterObjects(object_name, surface_name, count=10, scale_variation=(1, 1), rotation_variation=(0, 360)):

"""

Scatters instances of an object over a polygon mesh surface.

:param object_name: <str> The name of the object to scatter.

:param surface_name: <str> The name of the mesh surface.

:param count: <int> Number of instances to create.

:param scale_variation: <tuple> Min and max scale factor.

:param rotation_variation: <tuple> Min and max rotation in degrees.

:return: <None>

"""

# Validate object and surface existence

if not cmds.objExists(object_name):

cmds.warning("Object '{}' does not exist.".format(object_name))

return

if not cmds.objExists(surface_name):

cmds.warning("Surface '{}' does not exist.".format(surface_name))

return

try:

# Get the MObject for the surface

selection_list = om.MGlobal.getSelectionListByName(surface_name)

if selection_list.length() == 0:

cmds.warning("Could not find surface '{}'.".format(surface_name))

return

dagPath = selection_list.getDagPath(0)

mfnMesh = om.MFnMesh(dagPath)

except Exception as e:

cmds.warning("Failed to initialize MFnMesh for surface '{}'. Error: {}".format(surface_name, e))

return

# Iterate over polygons and get their areas

face_areas = []

total_area = 0.0

face_indices = []

mesh_iter = om.MItMeshPolygon(dagPath)

while not mesh_iter.isDone():

area = mesh_iter.getArea() # API 2.0: getArea() takes no arguments

face_areas.append(area)

total_area += area

face_indices.append(mesh_iter.index())

mesh_iter.next()

# Create cumulative areas for weighted random selection

cumulative_areas = []

cumulative = 0.0

for area in face_areas:

cumulative += area

cumulative_areas.append(cumulative)

# Function to select a random face index based on area

def select_random_face(cumulative_areas, total_area):

r = random.uniform(0, total_area)

for idx, cum_area in enumerate(cumulative_areas):

if cum_area >= r:

return idx

return len(cumulative_areas) - 1 # Fallback to last face

# Function to sample a random point within a triangle using barycentric coordinates

def sample_point_in_triangle(p1, p2, p3):

u = random.uniform(0, 1)

v = random.uniform(0, 1 - u)

w = 1 - u - v

point = om.MPoint(p1.x * u + p2.x * v + p3.x * w,

p1.y * u + p2.y * v + p3.y * w,

p1.z * u + p2.z * v + p3.z * w)

return point

# Function to sample a random point within an n-gon by triangulating it

def sample_point_on_ngon(face_points):

"""

Samples a random point within an n-gon by triangulating it.

:param face_points: <list> List of MPoint objects defining the polygon vertices.

:return: <MPoint> A random point within the polygon.

"""

if len(face_points) < 3:

return face_points[0]

# Triangulate the n-gon (fan triangulation)

triangles = []

p0 = face_points[0]

for i in range(1, len(face_points) - 1):

triangles.append((face_points[0], face_points[i], face_points[i+1]))

# Calculate areas of triangles

triangle_areas = [triangle[0].distanceTo(triangle[1]) * triangle[0].distanceTo(triangle[2]) * 0.5 for triangle in triangles]

total_area_ngon = sum(triangle_areas)

cumulative_areas_ngon = []

cumulative_ngon = 0.0

for area in triangle_areas:

cumulative_ngon += area

cumulative_areas_ngon.append(cumulative_ngon)

# Select a triangle based on area

r = random.uniform(0, total_area_ngon)

selected_triangle = triangles[-1] # Default to last triangle

for idx, cum_area in enumerate(cumulative_areas_ngon):

if cum_area >= r:

selected_triangle = triangles[idx]

break

# Sample a point within the selected triangle using barycentric coordinates

p = sample_point_in_triangle(*selected_triangle)

return p

# For each instance

for i in range(count):

# Duplicate object

dup = cmds.instance(object_name, name="{}_scatter{}".format(object_name, i+1))[0]

# Select a random face based on area

face_idx = select_random_face(cumulative_areas, total_area)

# Get the vertices of the selected face

face_vertices = mfnMesh.getPolygonVertices(face_idx)

face_points = [mfnMesh.getPoint(v, om.MSpace.kWorld) for v in face_vertices]

# Compute a random point on the face

if len(face_points) == 3:

# Triangle face

p = sample_point_in_triangle(face_points[0], face_points[1], face_points[2])

elif len(face_points) == 4:

# Quad face, split into two triangles

if random.choice([True, False]):

# First triangle

p = sample_point_in_triangle(face_points[0], face_points[1], face_points[2])

else:

# Second triangle

p = sample_point_in_triangle(face_points[2], face_points[3], face_points[0])

else:

# For n-gons, sample a point by triangulating

p = sample_point_on_ngon(face_points)

# Move object to position

cmds.move(p.x, p.y, p.z, dup, absolute=True)

# Random rotation around Y-axis

rot = random.uniform(rotation_variation[0], rotation_variation[1])

cmds.rotate(0, rot, 0, dup, relative=True)

# Random scale

scale_factor = random.uniform(scale_variation[0], scale_variation[1])

cmds.scale(scale_factor, scale_factor, scale_factor, dup, relative=True)

print("Scattered '{}' over '{}'.".format(object_name, surface_name))

# Usage example:

scatterObjects('pSphere1', 'pPlane1', count=50, scale_variation=(0.5, 1.5), rotation_variation=(0, 360))

[Today’s Challenge is to take this simple code to next level.. I am sharing images of these advanced codes...]