Blender modeling Notes

This page documents my first steps learning blender. I’ll also add to the page over the next week or two as I explore more of what blender can do. So far I’m really impressed. Note: – Page last added to on 18/10/17

As blender relies heavily on numPad keys,  and the “emulate numpad” overrides various shortcuts, I’m using a numPad keyboard for easy access on the left of my keyboard.

numPad

Hotkeys:

Navigation:

  • MMB = Orbit
  • Ctl + shift + Middle Click /or/ Scroll Wheel = Zoom
  • Shift + F5 = Viewport
  • 0(numPad) = Camera Mode (Enter/Exit)
  • 5 = Orthographic Perspective
  • 1/3/7(numPad) = Front/Right/Top View
  • Ctl + 1/3/7(numPad) = Back/Left/Bottom
  • Home = Frame All
  • .(numPad) = Frame Selection
  • Shift + C = Reset Viewport
  • Shift + F = Video Game Navigation

Object Viewing – In Viewport:

  • /(numPad = Frame Selection
  • Z = Wireframe
  • Alt + Z = Toggle Texture/Shader
  • Shift + Z = Toggle rendered/Shaded
  • (Shift + B + release) + Drag = Zoom into Portion

Editing/Creating Objects:

  • Shift + A = Add Objects
  • Ctl + Tab = Switch Edge/Vertex/Face panel
  • Tab = Edit Object Mode
  • Left Click = Move 3D Cursor
  • Ctl + A = Apply objects transformations (like freeze trans)
  • Y = Edge Split
  • Ctl + 1/2/3/0 = Subdivision Amount
  • Ctl + # = Add Subdivisions
  • U = UV uwrap
  • K = Knife Tool
  • I = Inset
  • E = Extrude
  • Alt + M = Merge Vertices (options panel ex: merge to centre)
  • Ctl + R = Loop Cut(Scroll wheel to add loops – pre right click)
  • Ctl + J = Join Objects
  • Ctl + B =Bevel (scroll for subdivs)
  • G + G = Slide Vert/Edge/Face
  • V = Rip
  • Alt + V = Duplicate Edge Loop on Object
  • F = Fill/Bridge Edges/Verts
  • P = Separate Selected (Verts/Face/Edge)
  • G + O = Offset and slide vert across edge

Within the Sculpt Brush

  • D = Draw Tool
  • Click + Drag = Add
  • Shift + Click + Drag = Subtract
  • F + Drag = Brush Radius
  • Shift + F + Drag = Brush Strength
  • C = Clay Brush
  • 2 = Clay Brush
  • G = Grab Brush
  • 7 = Grab Brush
  • I = Inflate/Deflate Brush
  • 8 = Inflate/Deflate
  • Shift+5 = SculptDraw
  • Shift+6 = Smooth
  • S = Smooth Brush
  • Shift+C = Crease Brush
  • L = Layer Brush
  • 9 = Layer Brush
  • M = Mask Painting
  • 0 = Mask
  • K = Snake Hook Brush
  • Shift+T = Flatten/Contrast Brush
  • P = Pinch/Magnify Brush
  • 1 = Blob Brush
  • 3 = Clay Strips Brush
  • 4 = Crease Brush
  • 5 = Fill/Deepen
  • 6 = Flatten/Contrast Brush
  • Shift+1 = Nudge Brush
  • Shift+2 = Pinch/Magnify Brush
  • Shift+3 = Rotate
  • Shift+4 = Scrape/Peaks
  • Shift+7 = Snake Hook
  • Shift+8 = Thumb

 

Moving Objects:

  • G = Move  (+ X/Y/Z to Constrain)
  • S = Scale   (+ X/Y/Z to Constrain)
  • R = Rotate (+ X/Y/Z to Constrain)
  • G + 5 = Move 5 Units
  • R + 2 = Rotate 2 Units
  • W = Panel (select Bridge)
  • Shift + C = Cursor at 000 (plus frame focus)

Selecting;

  • A = Select/Deselect All
  • B(release) + Drag = Box Selection
  • B(release) + Drag + Shift = Box Deselect
  • B(release) + Left Click(drag) = Rectangle Select(add)
  • B(release) + Middle Click(drag) = Rectangle Select(Remove)
  • C + Left Click = Circle Selection(add) – (+ Scroll for Circle Radius change)
  • C(release) + Shift = Circle Selection(remove) – (+ Scroll for Circle Radius change)
  • Ctl + Left Click – Lasso Selection(add)
  • Ctl + Shift + Left Click – Lasso Selection(add)
  • Alt + Right Click = Select Edge Loop
  • Ctl + Alt + Right Click = Select Edge Ring
  • L = Select shared Verts/Edges/Faces
  • Ctl + +(numPad) / (numPad) = Grow/Shrink Selection

Duplicating/Deleting/History/Hiding Objects:

  • H = Hide
  • Shift + H = Hide Unselected
  • Alt + H = Unhide
  • X = Delete Panel
  • Shift + D = Duplicate
  • Alt + Shift + D = Duplicate
  • Ctl + Alt + Z = Undo History Panel

Snapping/Cursor;

  • Shift + S = Snap Cursor to Selection
  • Ctl + Shift + Alt + C = Set Origin (Geo to Origin/Origin to 3D cursor etc)
  • Shift + S = Cursor options (ex: Cursor to center)

Animation:

  • Alt + A = Play/Pause
  • Shift + Alt + A = Play in Reverse
  • Left/Right Arrows = Next/Previous Frame
  • shift Left/Right Arrows = Beginning/End of Timeline
  • Shift + Up/Down Arrows = Jump Forward/Back 10 Frames

Windows & Panels:

  • Shift + Spacebar = Window Focus
  • Ctl + Ring Arrow = Scroll through window setups
  • Shift F4 = Python Console
  • Shift + F10 = UV Unwrap Window
  • F10 = Image Window
  • Shift + F7 = Editing Window (modifiers etc)
  • N = Transform Window Toggle
  • T = Tool Bar Toggle
  • Ctl + I = Invert Selection
  • Shift + F9 = Outliner
  • Shift + F3 = Node Editor
  • Shift + F11 = Text Editor
  • Shift + F7 = Properties Editor
  • Shift + F2 = Logic Editor
  • Ctl + .(NumPad) = Object Focus
  • Spacebar = Search Menu

Layers:

  • M = Move object to Layer Panel
  • 1/2/3/4 etc = Layer number

Changes that I found to be useful.By right clicking on a menu we can add a shortcut hotkey to an item. We can also add it directly into user Preferences/Input:

 

addHotKeySmoothShade01

Hotkeys added:

  • Ctl + ` = Smooth Shade

I also switched the ‘”select with” mouse buttons around:

mouseClickSwap

I’m used to the way the Maya Viewport looks so I installed the following “Maya Lover” Theme from Here. It’s just cosmetic but I like it.

mayaTheme

Modeling Practice – Ant (I’ll document my first modeling attempt in blender)

  • Shift + S to center the cursor via the panel
  • Shift + A to add – mesh – cube

BLENDER_ANT_01

  •  Ctl + R to place a loop cut through the center of the object
  • Z to make the object transparent (so we can select the back faces)
  • 1(numpad) to switch to front view
  • B + Release + drag for rectangular selection of left side faces

BLENDER_ANT_02

  • Spacebar – “type add m” bring up the add modifier panel
  • Add mirror modifier

BLENDER_ANT_03

BLENDER_ANT_04.jpg

  • To constrain the central verts to the Y and Z axis we need to enable “clipping”:
  • To see the mirrored mesh we need to turn on “cage to modified result”:

BLENDER_ANT_05

  • Show the back facing verts so we can select them

BLENDER_ANT_06

  • Base mesh for the head, abdomen and thorax.

BLENDER_ANT_07

BLENDER_ANT_08

  • Extruding some legs

BLENDER_ANT_09

  • Within the transforms window(N) / display / Shading there are a number of Metcap shaders which are excellent for picking up surface imperfections while modeling.

BLENDER_ANT_10

  • Subdivisions with cage

BLENDER_ANT_11

  • To isolate an area for modeling the details we select the faces we want to isolate and Shift + H.

BLENDER_ANT_12

  • A little more tweaking

ant04

—————————————————————————————————————

Testing Out the Sculpt Brush

  • Before starting to sculpt – Apply Mirror Modifier and delete Subsurface Modifier if we are starting from a model created with the above method

BLENDER_ANT_13

  • Spacebar + “add m” to add modifier  Multiresolution

BLENDER_ANT_14

  • Switch to sculpt mode
  • For roughing in a sculpt we can switch to Dynopo

BLENDER_ANT_16

  • Choose Brush and start sculpting

BLENDER_ANT_17

  • Hotkeys of Note: F = Brush Radius Shift F = Brush Strength
  • Sculpting from a poly UV Sphere, (in Dyntopo mode), allows us to sculpt in a similar way to zbrush – as we would in real life with clay.

faceSculpt01

Once we are happy with a Dyntopo sculpt we can retopologize the mesh in one of two ways:

  1. The easy way is to buy a script like “RetopoFlow” which appears to be similar to Maya’s quad draw tools.
  2. The second/free way  is explained HERE  by Zacharias Reinhardt.

Process notes:

  • Create plane with cursor at 000.
  • Ctl + R to slice in half and delete Left Side
  • Add Mirror modifier Enable clipping
  • Add Subsurf modifier and set as simple (not Catmull-clark)
  • Add a Shrink Wrap modifier and choose target mesh and set the offest to .002 and enable keep above surface and make sure the triangle icon is enbled so as to see the Verts
  • To avoid selecting verts on the other side – (alt + b = Clipping border) – (alt + b to remove clipping border).

Alpha brushes in sculpt mode:

BLENDER_ANT_22

  • choose brush mapping style

BLENDER_ANT_23

  • We can use a stencil – (note hotkeys: RMB = move stencil / shift + RMB = Scale Stencil / Ctl + RMB = Rotate stencil)

BLENDER_ANT_24

  • Some details added to the mesh with alpha brushes

details

  • With a shiny gold met material we can see more details

BLENDER_ANT_26

Modeling with Blender’s Skin Modifier

Setup:

  • Create plain(shift + C to center Pivot) / Alt + M  / Merge at center / Edit Mode / Spacebar/“Add Modifier” / Mirror/Skin/SubDiv 

Modeling:

  • Extrude + G + Move / Ctl + A(x,y,z) for Scale / Ctl + R = Add Vert

Test – Bipedal Character:

  • Starting with Torso and Feet – a little bit tricky

new01b

  • Attempt at constructing the hand

hand01

  • Base mesh completed

baseMesh02

  • From here we could use the sculpt tools to refine the character and then retopologize the mesh once we are happy.

 In sculpt mode – start clay style sculpting:

  • Clay Brush / Area Plane 
  •  Dyntopo Enabled / + Subdivide Edges / + Brush Detail

  •  Ogre type creature created from the base mesh using the above brush settings


Blender is a much loved, free and open source 3D application with a thriving user community. It was originally created by Ton Roosendaal as an in house software tool at  NeoGeo – an animation studio he co-founded. It was later released as free creation tool.

Visit:

Open Project Films created by the Blender foundation:

Advertisements

Organic Shapes from Nparticles – Maya

Some experiments creating organic shapes from particle motion. I found a few useful scripts and have linked to them and their creators.

  1. Particle set up for testing

SETUP_NPARTICAL_MOVE

2. Turning these particles into curves

There are two ways to do this.

The first involves expressions which allow the curves to be draw in real time. 3D Splanchnic has a tutorial showing what to put where. Watch it HERE.

code for expressions:

mel_Parts_to_curve

(update: if ( frame%10 == 0)  is simpler)

The second is a script. Bryan Woodward’s ‘ParticletoTube’ Script for Maya makes tubes out of particles by first creating curves. The first part of the script loops through the timeline frames for “theParticle” and then uses a nested loop to capture each “particlesPosition” and draws each curve form the “pointList”. Read about the script HERE.

Code:

partsToCurvesScript

Now I can change my particles into Curves

CurvesFromParticles02

Note: I have connected my nParticles to mash with a polySphere connected to the repo-node.

nParticles_plus_mash.jpg

3. Finally I need a script to turn these curves into organic looking geometry. Andrew Tubelli has a nice script for doing just that. Download it from his site HERE

The code simplifies what would be an annoying task by adding a UI with a few friendly sliders:

coral2

Completing the process via the maya UI instead of the script:

nParticles_to_poly_old_way

The code rebuilds the curves based on “arcLen”, creates nParticles for the curves and evaluates a mel command to create polygons with the ability to set attributes Via a UI.

curveToGeoScript

None: Some variable Changes are occasionally needed. For example the  curves generated by particles can be excessive – Try changing the (arcLen)*5 to say (arcLen)/5 or just add it into the UI. I also needed to up the ‘.maxTriangleResolution’ count.

Example:4. A few shapes generated by moving a passive collider around so as to alter the particle movement.

PARTICLES_TO_CURVES_04

5. Now an experiment just from wires. I used a skull I previously modeled to draw curves on and then turned the curves into geometry.

Preiew render experiment

Some paint effect brushes added:

Instancing test using Maya’s Mash + Vray

This is a test for instancing grass with Mash in Maya. Very simple. Very quick. The settings are low and the render took next to no time. Perfect for previewing.

Oh how I am going to love using mash… and it has a python node!

I recently delved into writing some math nodes for Maya with python, (and compiling them in c++), with the idea of building something like what Rhino has with Grasshopper. It’s turning into an excellent learning exercise. However, mash already has a lot of what I always wanted Maya to have. So… fun times ahead.

To test out some instancing using Maya’s Mash

1. Paint Effect for grass  – converted to polygon quads;

2. UV’s organized 3X3. Vray 2 sided shader applied:

 

3. I thought I would throw in an old skull I poly modeled a long time ago. I decimated it in Zbrush, instead of using a displacement, and gave it a Vrays SSS shader. Here is a time-lapse of the Maya session:

4. In mash I instanced the grass over a plane and created a falloff object to mute the grass around the skull within a strength node. I also added a random node to the mix.

 

There is so much artistic control with this kind of procedural approach. Change, add, swap, blend, randomize, mute, duplicate etc.

Notes – Nodes & Mash – Maya

Here are some learning notes on creating a node plug-in for Maya, an example of it as an expression. These are just for me but perhaps others may stumble upon them and find them to be of interest. I’ll probably change and grow this page as I learn a little more.

  1. Notes and links on how to create a Maya plug-in

Autodesk have an example Python Math Node. Here are my notes:

  • API module: import maya.openMaya
  • Proxy class access: import maya.openMayaMPx
  • Access to math module: import math
  • Variable for node name:  kPluginNodeTypeName = “nodeNameNode”
  • ID number for Node:        nodeNameNodeId = OpenMaya.MTypeId(0x00001)
  • Define subclass of existing class: class nodeName(OpenMayaMPx.MPxNode)
  • input = OpenMaya.MObject()
  • output = OpenMaya.MObject()
  • Override constructor using base: OpenMayaMPx.MPxNode.__init__(self)
  • plug = current input: def compute(self,plug,dataBlock):
  • Compute math example: result = math.sin( inputFloat )
  • Recompute plug and flag as clean: dataBlock.setClean( plug )
  • Maya pointer: return OpenMayaMPx.asMPxPtr( sineNode() )
  • Initialize method – input and output: nodeInitializer():
  • Add attribute here (ex- frequency or or amplitude): input = nAttr.create( “input”, “in”, ####)
  • Causes compute method to re-calculate – sets relationship: sineNode.attributeAffects( sineNode.input, sineNode.output )
  • Plug-in registration – Node Name/ID/Create Method/Initialize Method/Node Type: mplugin.registerNode( kPluginNodeTypeName, sineNodeId, nodeCreator, nodeInitializer )
  • De-register plug-in: mplugin.deregisterNode( sineNodeId)

Understanding this we can now turn these python math functions into Maya nodes:

programming-with-python.jpg

2. Some links to various resources:

Classes:

  • Wrappers – math classes – m -(Quaternion, matrix, vector, points, vectors etc)
  • MObjects – data encapsulation (meshes, skin clustter nodes, curves  etc).
  • Functions Sets  mfn  – (access and manipulate data)
  • Proxy Classmpx – – (abstractions – create new object types – inheritance)

For memory intensive process plug-ins need to be complied in c++. Here are some links:

3. Example: Testing cosine node works.

radTimesSinCos01

radCosSonCirclesMayaNodes01

3. A Mel expression that does the exact same thing. A little bit less work 🙂

radTimesSinCos01_expression

Two very simple expressions that create tangent circles (also known as kissing circles).

melExpression-KissingCirclesNWJ

relationshipsWithExpressions

Nodes and expressions can build almost any kind of relationship we want. If the task is process hungry its best to compile.

4. Mash Nodes – Python node

mashNodes01.jpg

Python Node Test with controllers piped in as variables – Expression: (cos(t) + cos(6t)/2 + sin(14t)/3, sin(t) + sin(6t)/2 + cos(14t)/3) – (see article “Creating Art with Mathematics”)

paterns_maya_pythonNode_mash03

 

radCosSonCirclesMayaNodes04paterns_maya_pythonNode_mash

 

 

Metallic Carpenter Bee (Xylocopa (Lestis)) – Poly Modeling

Modeling – MayaCarpenterBeePolyModeling_nwjones02

FinModelCarpenterBeeNWJONES

Shader Dev – Maya Vray

  1. Super simple – Just falloff curves for red green and blue. Trying to match some photo reference of an iridescent beetle – source from here
    beeBeetleShd03
  2. A test render using “Thin Film Interference”. An explanation for the code used can be found HERE (gamedev.net) and the OSL shader code can be found HERE (chaosgroup.com). This is a work in progress but I like the general direction its going. More hair and some modeling tweeks are obviously needed. Photos of the actual bees can be found HERE. They’re quite pretty.NWJONES_WIP_CARPENTER_BEE02

First Experiments using Grasshopper for Rhino

Grasshopper for Rhino – A visual programming language/environment.

This is a blog post of notes made whilst using Grasshopper for the first time.

Circles and Triangles

Above: Solving for x²+y² = r² . Nodes used: I created two number sliders for variables – (Radius & Adjacent side), along with an expression evaluate node, square root node and vector node for XYZ.

Above: I created a Theta variable and plugged it into the Cosine(sideX) and Sine(sideY) functions, as degrees, and then into a Vector XYZ node. Math revision – SohCahToa

Above: Cos and Sin multiplied by radius.

Above: I created a variable for the radius of pivot circle and multiplied it *2 to find the center point distance of the orbiting circle. I input the arc variable as radians – rad(x). Note: Input for expressions = x

Above: I added a 2nd circle with the expression Acos(1/2) and added the Arc variable to it. Note that the corresponding angle is 60° .

img_0577-11.png

Unit Circle reference image above from: Inverse Trigonometric/ArcCos.

I added more circles.

rotateArchCircles04bAbove: By shift dragging connections we can connect multiple links and post-it note style lists help visualize inputs/outputs. We could also use the merge node.

Function Curves

Construct Domain node (DOM) – Start Value (-10) End Value (10) (= -10 to 10)

Range Node – Give domain (-10 to 10) and steps (creates even spacing for steps within the domain – for example 10 will give a list of  steps each at 1/10th the domain).graphsCreate2

Interesting use of expressions for curves – see this article. I input a variety of variables, as number sliders, to create these pretty patterns.interestingFunction02

Unit circle

2 π = 360 degrees. 1 π = 180 degrees. I created two expressions, (cos(x* π) and sin(x* π), as vectors x and y to simulate the unit circle. The range node automatically generates a 10 number list within a domain (D). When we set the domain to 2 (2 π) we get a complete rotation of our unit circle. It works the same way with a node tree instead of an expression.

unitCircExpress

unitCircle

unitCircNodes

Pappus Chain

First I set up a simple relationship between three circles. As the radius of one circle increases the other decreases respectively. The magnitude of each  vector also increases or decreases to offset the change in radius . All three circles remain tangent.papuisRing03c

03_papuisRing03

Next I wrote an expression to invert the top circle and tested it with some tangent lines.papuisRing04

03_papuisRing04

After a little bit of reading I found a number of ways to place the chain of circles. The most direct way is to calculate a three point circle from intersection points.

By extruding a number of tangent lines I was able to extract the necessary points using the curve|curve tool. Split nodes, set to integer 1, were needed to split the list generated when more then one intersection occurred.papusCain02

pappusChainIntersections

03_papuisRing01

Circle number 2 added. Interesting but not very practical.papChainN2

With one circle created there is enough information to generate an ellipse. Math Revision – x²/a² + y²/b² =1
papsCh008

More circles added.

pappusCh006

“Series” nodes iterate versions of the top circle with 2*radius for steps. Lines from each circles center point intersect with the ellipse.papusCain03There are a bunch of interesting articles about the Pappus Chain. It would be a lot of fun to dive in more deeply and explore the mathematics properly. It’s a very interesting subject.

Epic Circles – Numberphile

Pappus Chain – Wolfram – Math World

Arbelos

Steiner Chain

Wiki – Pappus Chain

Chain Reaction

Reuleaux Skyscraper

It seems that everyone who uses Grasshopper for Rhino builds a skyscraper first. So why not. I’ll try a simple mathematical shape – A Reuleaux Triangle. It’s an interesting enough shape.

“Rotation of a Reuleaux triangle within a square, showing also the curve traced by the center of the triangle”

Rotation_of_Reuleaux_triangle

See Wikipedia entry

A Reuleaux Triangle is a shape formed from the intersection of three circular disks, each having its center on the boundary of the other two.reuleaux_circle01c

Above:  Before and after trim using region difference nodes to extract the reuleax triangle shape.

Twisting Node tree tests

Series node with inputs to control the count (number of levels), the rotation of levels (in degrees), and the step size (size between levels).Untitled

More control added with rotation variables for rotating the the start and end of the building.Untitled2

After a little more reading, and watching some youtube tutorials, I created my first grasshopper building. Not very interesting but it doesn’t have to be. Its just for learning.reuleaux_circle01D2

The node tree can be visualized with a param Viewer node which can display the tree visually – see node tree image.SkyScraperNodeTree

Grasshopper creator, David Rutton, has a video about data trees here.datatree

Nodes of note for data manipulation/deconstruction:

DataManipdeconstructData

To be continued…