Digital Tutors: Max or Maya

Since it’s becoming more of a necessity with every passing day I’m going to devote my time into learning a modeling program. I saw someone reply to a thread mentioning Digital Tutors and decided to look it up, the site looked promising me so I wondering if I should invest in it.

The payment is $45.00/month which I have absolutely no problem paying.

However, I’m wondering two things:

A. Should I invest into this site? Or is there another tutorial site that surpasses Digital Tutors?

B. Disregarding what site I choose to learn from, in the long run: Should I learn 3Ds Max or Maya?

Notes:

I want to (eventually) learn how to model things such as medieval props to fill interiors as well as medieval weapons and armor. I also want to learn how to create organic models, for example: Goblins, Humans, etc. Fantasy shit.

So mainly I’m wondering what program caters best to my goals?

Site (not intended as an advertisement, only a reference):

Main Site:
http://www.digitaltutors.com/09/index.php

3Ds Max:
http://www.digitaltutors.com/09/training.php?cid=106

Maya:
http://www.digitaltutors.com/09/training.php?cid=5

i think your get more out of it all if you learn the program from free videos over the web first, then you can watch better videos for the price your paying… also its a much faster process once you know your way around.

Just to note, learn both but start with maya i think. Me personally i’ve used both max and maya. I found maya to be much nicer interface to work with. It has it’s pros and cons compared to max, but its all down to personal preference and where you wanna take it.

People have said that Max is better for games and architecture and I’m sticking with that. Maya has built in Fluid dynamics and all that. It’s used in movies a lot. I would think 3ds max is better for modeling.

And if you DO choose 3ds max…Check out hammerbchen’s tutorials on youtube. I started there.

if im honest… maya for me is a lot easier to model with then max. I’ve also found animation to be a lot easier. I agree max is supposed to be better for games but maya defiantly has a few things up on max

At the end of the day i think you gotta have an open mind about all programs because i know on our course we will be using xsi, max and maya because they all have pros and cons… one thing which the other has but isnt as good. Also zbrush and mudbox. Houdini etc… theres a lot of programs we will be learning.

read this… http://www.ehow.com/about_5387054_maya-vs-studio-max.html like i said all depends where you wanna go with it. A cool feature maya has, is the use of python to script. Which can save a bundle or time. Also it runs on max and linux which max doesnt.

Both are excellent modeling programs. I’m more used to Max, so if I had to choose- I’d take Max. I’ve only played around with Maya, never really did anything with it. They say it’s much more “powerful” than Max.

My instructor in college built the same exact character in both Max and Maya. He had the the character in Maya built in half the time it took to build the same character in Max. So, I guess it’s more along the lines of what you feel comfortable with.

There are free versions available (no I’m not talking about warez). Check out Maya PLE and Gmax. Both sort of lack export capabilities (you can probably find export scripts somewhere). But they are good for learning on and testing out.

Thanks, I appreciate the responses. How about for organic modeling? Do any of you have opinions of which is better to use for organic modeling?

I use maya for organics, and find it a lot easier. Id say as potemkis said, its quicker then max, I find it easier to navigate to different tools etc… its just more user friendly I think. Here’s a recent piece I did in maya then photoshop.

http://img532.imageshack.us/img532/8822/stage11.png

This took i’d say 1/ 2 hours of work. But it’s just a flat face, for a painting. But its a caricature of someone… guess who haha

Final Piece:

http://img268.imageshack.us/img268/2518/ccsfinalimagebobmarleyl.png

Also my hand model in production: (rigs done)

http://img46.imageshack.us/img46/3316/rig.png

http://img30.imageshack.us/img30/602/finishedl.png

If you are interested I also made a python code which basically copies and groups stuff… like a random generator. You can make tools that do all sorts, and its really easy to use. Python is piss easy to learn.Currently working on the most “un-original” gun model… Baretta 9000 so see how it turns out. But I will probably use my arm model to test it all out.

[editline]11:40PM[/editline]

If your interested in my script your welcome to try it out… (it was for my project so I’ve like… summarised everything. But yeh tell me what you think.


#!usr/bin/python
import maya.cmds as cmds # This imports the maya module as cmds.
import random # This imports the rand function.
import os

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#-------------------------------------------------------------|Random Generator Made by Lucien De Vivo 2010 |----------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#                                                                                                                                                                      #
#                                   This script is built to randomly generate objects and place, scale, rotate and group them.                                         #
#                                                                                                                                                                      #
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

'''
All Below are Random Statments, which link to the Buttons which generates objects and places, scales, rotates them. For the grouping see below.
'''

def RandObject(*args): # This makes a new function 'RandObject' - this will be used to hold all the values below. So its easier to link back.
    cmds.duplicate('ObjectA') # This Duplicates 'ObejectA'.

    cmds.select('ObjectA') # This selects 'ObjectA'.
    x = random.randint( 1, 100) # This is the random function in action. It will randomly select intergers from 1 to 100, and tie that interger to x.
    y = random.randint( 1, 100) # This will randomly select intergers from 1 to 100, and tie that interger to y.
    cmds.move(x, 0, y) # 'cmds.move' will move 'ObjectA' (selected object in the scene) thats why i seleceted it earlier. X and Y values will be made from the above actions.
    print x + y # This function will print where 'ObjectA' will be placed. Hence the 'X' and 'Y'.
    
    cmds.select('ObjectA') # This selects 'ObjectA'.
    z = random.randint( 1.0, 3.0) # This will randomly select an interger for 'z' between 1.0 and 3.0.
    cmds.scale(z, z, z) # Depending on the random interger it will scale the object.
    print z # This prints the intergers that random has selected.

    cmds.select('ObjectA') # This selects 'ObjectA'.
    r = random.randint( 0, 360) # This will randomly select an interger for 'r' between 0 and 360. 
    cmds.rotate(0, r, 0) # I have made the numbers '0' on the left and right of the brackets, because i only want the object to rotato on one axis.
    print r # This will print what angle the object has been rotated.
    
    print 'Object Randomly created, placed and scaled!' # This is the message that will appear after the object has successfully completed all above functions.

def RandObject1(*args):
    cmds.duplicate('ObjectB')

    cmds.select('ObjectB')
    x = random.randint( 1, 100)
    y = random.randint( 1, 100)
    cmds.move(x, 0, y)
    print x
        
    cmds.select('ObjectB')
    z = random.randint( 1.0, 3.0)
    cmds.scale(z, z, z)
    print z

    cmds.select('ObjectB')
    r = random.randint( 0, 360)
    cmds.rotate(0, r, 0)
    print r
    
    print 'Object Randomly created, placed and scaled!'

def RandObject2(*args):
    cmds.duplicate('ObjectC')

    cmds.select('ObjectC')
    x = random.randint( 1, 100)
    y = random.randint( 1, 100)
    cmds.move(x, 0, y)
    print x
    
    cmds.select('ObjectC')
    z = random.randint( 1.0, 3.0)
    cmds.scale(z, z, z)
    print z

    cmds.select('ObjectC')
    r = random.randint( 0, 360)
    cmds.rotate(0, r, 0)
    print r

    print 'Object Randomly created, placed and scaled!'

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#-----------|All the below 'def' statments do the same thing but for different 'objects', refer to the top statment for information on how i did it.|------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

'''
All Below are Grouping Statments, which link to the 'menuItems', it will make the different selections group, either as a whole or indervidually.
'''

def grup(*args): # The name of the 'def' = 'grup', once again save time.
    cmds.select('ObjectA*') # This selects all objects under the name 'ObjectA' the '*' will tell it to select all with that name.
    cmds.group(name='Object_A') # This will then place them into a group called 'Object_A'.
    cmds.select('ObjectB*') 
    cmds.group(name='Object_B')  
    cmds.select('ObjectC*')
    cmds.group(name='Object_C')
    #   This Groups them all together.

def grupA(*args):
    cmds.select('ObjectA*')
    cmds.group(name='Object_A')
    #   This groups ObjectA's to Object_A
    
def grupB(*args):
    cmds.select('ObjectB*')
    cmds.group(name='Object_B')
    #   This groups ObjectB's to Object_B   
def grupC(*args):
    cmds.select('ObjectC*')
    cmds.group(name='Object_C')
    #   This groups ObjectC's to Object_C

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#---------------------------------------------|All the below 'def' statments make the 'Help' box up and the 'About' box.|----------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

#   About

'''
The About 'def', in short, opens up a new windows box. This window will provide the user with information on the program i.e. who made it and when.
'''

def About(*args): # Named the 'def' function to save time.
    cmds.window (menuBar=True, title='About - Object Generator', sizeable=True) # Given the windows box a 'menubar' and gave it the title, 'About - Object Generator'. Also have given the user rights to change the size of the window.
    cmds.frameLayout(label='About', labelAlign='top', borderStyle='etchedIn') # Here i designed the style of the 'frame', given it a border and put 'About' as a title, aligned it 'top'
    cmds.columnLayout() # ColumnLayout is needed for the window to work.
    cmds.text(label='This is an Object Generator it will randomly generate any objects. 
It will group, place, scale and rotate them.', align='left') # This is information 'text' for the user.
    cmds.text(label='
Made by 
Lucien Alberto De Vivo 2010', align='left') # This is information 'text' for the user.
    cmds.text(label='
Email Address 
lucien.alberto.devivo@hotmail.com', align='left') # This is information 'text' for the user.
    cmds.showWindow() # showWindow() is needed to see the window.

#   Help

'''
The Help 'def', in short, opens up a new windows box. This window will provide the user with information on how to use the program. Also just make it more user friendly.
'''

def Help(*args):
    cmds.window(menuBar=True, title='Help - Object Generator', sizeable=True)
    cmds.frameLayout(label='Help', labelAlign='top', borderStyle='etchedIn')
    cmds.columnLayout()
    cmds.text('This program will randomly generate any object. Provided it is named
correctly.
The generator will copy objects, group, place, scale and rotate them.
 ', align='left')
    cmds.text('To use it these are the steps you must follow:
1. Name your first object \'ObjectA\'
2. Name your second object \'ObjectB\'
3. Name your third object \'ObjectC\'

', align='left')
    cmds.text('This script will also group the objects in files named.
Object_A
Object_B
Object_C

Thanks for using my program :)', align='left')
    cmds.showWindow()

#   grupOptionBox
'''
The 'grupOptionBox' is basically the an alternative to creating groups. Basically you can choose what you want to go in a group, So if you only want all 'ObjectA's'
in a group but not B's or C's then you can do this here.
'''

def grupOptionBox(*args): # defining the name, save time later.
    cmds.window (menuBar=True, title='Grouping - Object Generator', sizeable=True) # Given the window box a menu bar, with a title - 'Grouping - Object Generator' And made it user-sizable.
    cmds.frameLayout(label='Grouping', labelAlign='top', borderStyle='etchedIn') # This is just desinging the look of the frame, Etched in and titles, and postioning.
    cmds.columnLayout() # ColumnLayout is needed for the window to work.
    cmds.text(label='Select What you would like to Group.') # Text identifing the purpose (user friendly)
    cmds.rowColumnLayout(numberOfRows=1, columnOffset=(1, 'both', 4)) # Here i am arranging the buttons, on a column, the offset etc..
    cmds.button(label='Group ObjectA', command=grupA) # Here i have given the buttons names and set the command to a previous 'def' in this case 'grupA', which i made earlier.
    cmds.button(label='Group ObjectB', command=grupB)
    cmds.button(label='Group ObjectC', command=grupC)
    cmds.showWindow() # showWindow() is needed to see the window.
    
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#-----------------------------------------------------|All the below 'def' functions Delete groups and objects.|-------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

'''
Here i have made basic 'def' functions to delete the objects and object groups.
'''

def DeleteA(*args):
    cmds.select('ObjectA*') # This will select all the objects named 'ObjectA....' to what ever number.
    cmds.delete() # This function will delete the selected objects.

def DeleteB(*args):
    cmds.select('ObjectB*')
    cmds.delete()
    
def DeleteC(*args):
    cmds.select('ObjectC*')
    cmds.delete()

def DeleteGrupA(*args):
    cmds.ungroup('Object_A') # This will ungroup all the objects in 'Object_A' group.
    cmds.select('Object_A') # This will select the 'now' empty group.
    cmds.delete() # This will delete the selected group.
    
def DeleteGrupB(*args):
    cmds.ungroup('Object_B')
    cmds.select('Object_B')
    cmds.delete()
    
def DeleteGrupC(*args):
    cmds.ungroup('Object_C')
    cmds.select('Object_C')
    cmds.delete()

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#   Below i have set up my main window, as you can see i've set the title of the menu bar to, 'Object Generator - Lucien De Vivo' and made it scale-able which is what #
#   'sizeable=True' means. I have also set up the menu items (drop down selection of a window) with 'cmds.menuItem() then with the 'command' i can make it use the     #
#   'def' i made earlier i.e. 'cmds.menuItem(label='Help', command=Help)', which will link up to 'def Help(*args):.... ' Where i specified what Help was as a function.#
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#   Below the 'menu items', i have used 'frameLayout' to design the look of the window that will be opened. Specifiying the 'borderstyle' and label which will appear  #
#   'top', all this will help make the program 'user friendly'. I then input the text to make it clear what questions would be asked.                                  #
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

cmds.window (menuBar=True, title='Object Generator - Lucien De Vivo', sizeable=True) # This is the MAIN window box, so is named 'Object Generator - Lucien De Vivo' and is given sizebale window.
cmds.menu(label='Info', allowOptionBoxes=True) # This made a menu at the top such as 'File' or 'Edit'. Also allowed me to use option boxes i.e. for the Grouping option open up a new window.

cmds.menuItem(label='Group All', command=grup) # Here i made a group all button, which links to 'grup', made previously.
cmds.menuItem(optionBox=True, command=grupOptionBox) # This is the option box for the 'group all' button above, this links to the previously made grupOptionBox 'def'.

cmds.menuItem(divider=True) # Divider sepearted the different sections, so group from delete.
cmds.menuItem(subMenu=True, label='Delete') # Here i made a sub-menu for the 'Delete' menu. This will open a new menu from the exisitng one.
cmds.menuItem(label='ObjectA', command=DeleteA) # I made a menu button here, which deletes all objectA's, with preivous 'def' DeleteA command.
cmds.menuItem(label='ObjectB', command=DeleteB)
cmds.menuItem(label='ObjectC', command=DeleteC)
cmds.menuItem(divider=True) # Divide the objects from the groups.
cmds.menuItem(label='Group A', command=DeleteGrupA) # This will delete the 'Object_A' group. With the privous 'def' DeleteGrupA command.
cmds.menuItem(label='Group B', command=DeleteGrupB)
cmds.menuItem(label='Group C', command=DeleteGrupC)
cmds.setParent('..', menu=True) # this sets the parent to the menu.

cmds.menuItem(divider=True) # Divides the i delete menu from the 'About' and 'Help' functions.
cmds.menuItem(label='About', command=About) # 'About' command to preivous 'About' def.
cmds.menuItem(label='Help', command=Help) # 'Help' command to preivous 'Help' def.


cmds.frameLayout(label='Select', labelAlign='top', borderStyle='etchedIn') # Main window select border and layout.
cmds.columnLayout() # needed to work.
cmds.text('To Clone an object, randomly scale and place it choose
from the following.
', align='left') # Text explaining what to do.

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#    This is how the buttons will look                                                                                                                                 #
#                                                                                                                                                                      #
#   +--------+   +--------+   +--------+                                                                                                                               #
#   |        |   |        |   |        |                                                                                                                               #
#   |   B1   |   |   B2   |   |   B3   |                                                                                                                               #
#   |        |   |        |   |        |                                                                                                                               #
#   +--------+   +--------+   +--------+                                                                                                                               #
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

cmds.rowColumnLayout(numberOfRows=1, columnOffset=(1, 'both', 4))
cmds.button(label='ObjectA', command=RandObject)
cmds.button(label='ObjectB', command=RandObject1)
cmds.button(label='ObjectC', command=RandObject2)

#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#   The buttons above are linked to 'def' functions i made earlier, which group, scale, randomly place and rename all the 'objects'. Once again using the 'command' i  #
#   could easily make buttons user friendly and functional. Also using the 'rowColumn()' made arranging the buttons easy.                                              #
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#
#   'columnOffset' - The attachment offset for the specified column. The first argument is the 1- based column index. The second argument is the attachment,           #
#   valid values are "left", "right" and "both". The third argument must be greater than 0 and specifies the offset. (this is from the Maya2008 help commands website) #
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------#

cmds.showWindow()

#   showWindow, just allows the user to see the 'window', without this part the whole code would be pointless.