Shannon Hochkins @jinglezzz - Tumblr Blog

How to customize the home page of your Thecus NAS server!

If you're like me, and you're very picky with certain things, you'll notice that some things by default, aren't up to your likings, and with no UI to change these things, it can be a bit tricky to actually do it! So, I'm going to show you how I hacked together, a homepage for the Thecus N7700+, however this should work for most of the Thecus NAS servers. To start with, most of the content on the home page, is located in the login.tpl file under /img/www/templates/ In here there's plenty of things you can do to the home page, I'm not going to teach you html, php or javascript here, but it's a pretty basic setup! More or less all I did was remove the default text from Thecus, and added in my own module 'buttons'. Simple is good. You'll have to download your login.tpl file as by default, it only gives you read permissions. Once you have finished customizing you login.tpl file, you'd expect to just overwrite the original, but I think what Thecus does at boot, is clear the tpl files, and re load them from backups. Thus making our edits redundant, so what I did was the following: Make a directory under the root called /customised_tpl:

mkdir /customised_tpl

Once we have made the directory, upload our custom login.tpl to this folder. Now, what we need to do is update the old one, with the new one, once it has been placed in the original /templates folder. How can we do that? There was many ways that I tried this, but Thecus have limited the system, so there was also many ways I failed. I found a boot module called "META", which allows you to run custom scripts at boot or shutdown, which is exactly what we need! You can download this module from here. Once you install this module and enable it you'll be able to create a startup script! From terminal, type the following:

cd /raid0/data/module/META/system/etc/startup vi customStartupCommand.sh

You can use any text editor to create your customStartupCommand.sh, I just prefer vi, copy this script into your sh file:

#!/bin/sh umount /img/www chmod 777 /img/www mount /dev/cloop2 /img/www cp /customised_tpl/login.tpl /img/www/templates/adm/

Basically the above unmounts the img/www directory, changes it's permissions, re mounts it and then we are allowed to overwrite the login.tpl file. Just to be sure, I gave the system a reboot, and BAM! New simple homepage. If you have any questions about this I'm happy to answer them [email protected]

#thecus #nas #custom #hack #homepage

Batch Processing 3D Textures.

As some people may know, animating an object that has a 3D texture to it, will make it look just a tad silly... It will appear as if the texture is sliding on the objects surface.

It's a simple fix, you just create a texture reference object of the mesh that has the 3D texture attached to it, this will simply create a reference object, that will stay static to till the moving object, where it's UV's are on the texture.

What if you have hundreds of textures? or hundreds of objects? This can take some time...

Simple fix:

from pymel.core import * from maya.mel import eval shapes = ls(sl=1,o=1) if (len(shapes) != 0): for shape in shapes: select(shape,r=1) isComponent = isinstance(shape, (MeshVertex, MeshEdge, MeshFace)) if (isComponent): mesh = ls(sl=1, o=1) obj = mesh[0].listRelatives(ap=1)[0] shape = obj.getShape() else: obj = listRelatives(shape, p=1)[0] select(obj,r=1) eval('CreateTextureReferenceObject') obj.setAttr('miProxyRenderable', 0) shape.setAttr('castsShadows', 0) shape.setAttr('receiveShadows', 0) shape.setAttr('primaryVisibility', 0) else: warning('Please select something')

This script will loop over the objects and create the reference for you, as well is making it not renderable and invisible.

#python #mel #maya #texture #3d #reference #object #mesh #pymel

Creating my custom Rivet Locator- Pymel Tutorial

What's the aim? What are we creating?

We'll be creating a series of nodes that once all working together, will make a certain object follow the surface normals of a mesh section even when deformed, follow rotation and position in world space.

This tool is very similar if not the same as either creating a folicle on the surface or a pointOnPoly Constraint, however I wanted to tackle this my own way, and the pointOnPoly Constraint isn't my biggest fan...

I have a much more advanced version of this script, but I'll just go through the basic version to help you get started with Pymel.

NOTE:

Unfortunately, unless you have Maya 2014 which comes pre shipped with the decomposeMatrix node, you may have to add in this node to your bundle, or load it from the plugin manager.

First of all, what do we have to do?

We will have to trace a section of components, draw a surface from these components, decompose the matrix and connect it to our Rivet Locator

Let's start by importing our PyMel Module:

import pymel.core as pm

Now that we've done that, we can start writing our Rivet class!

Everything we're about to write, will be wrapped in a class, why are we using a class? I class has all the standard features of Object Oriented Programming, I class can be modified after creation, it's much nicer to read, and well, they're awesome.

So let's build our class and it's core functions:

class RivetSimple(): def __init__(self, *args): ## Perform various tasks on load of the script def setAttributes(self, *args) ## Define our attributes def createNodes(self, *args): ## Create our nodes for use for this tool def createConnections(self, *args): ## Create our connections to and from our nodes

The above is pretty simple, all we're doing is instantiating our main class, and functions that belong to it.

Okay, we're done here! Let's start with something simple, creating the nodes that we'll need throughout this little project.

We'll need 7 nodes to get this baby functioning the way we want, here's what we'll need and why:

curveFromMeshEdge - This node defines a NURBS curve that is derived from a mesh edge that's selected, we will need two of these nodes.

pointOnSurfaceInfo - This node will be used to compute information from the surface created when we loft our new curve edges, we'll be using this information to plug into a four by four matrix node.

fourByFourMatrix - This node can output a 4x4 matrix based on it's input, we'll be decomposing this matrix information to connect to our decomposeMatrix node.

decomposeMatrix - This Node, as it's name suggests, will decompose the inputMatrix from our 4x4 node, and convert it to easily accessible information to connect to our object.

loft - This node will simply be used to loft a surface between our two curveFromMeshEdge nodes we created earlier.

Locator - This node will simply be used so that we have something to parent or constrain to for animation.

Group - We'll be using a group node to group our locator, and connect our rig to this group so that we have an offset control (locator).

Hopefully that helps make you understand what/why we're creating these nodes.

Let's add the above nodes into our class function 'createNodes()'. We'll use a dictionary for these nodes as It's easier to access information and reads nicer.

Now that we have done this, let's make our connections! I'll add a comment in for each node connection.

class RivetSimple(): def __init__(self, *args): ## Perform various tasks on load of the script def createNodes(self, *args): self.node = { 'meshEdgeNode1' : pm.createNode('curveFromMeshEdge'), 'meshEdgeNode2' : pm.createNode('curveFromMeshEdge'), 'ptOnSurfaceIn' : pm.createNode('pointOnSurfaceInfo'), 'matrixNode' : pm.createNode('fourByFourMatrix'), 'decomposeMatrix' : pm.createNode('decomposeMatrix'), 'loftNode' : pm.createNode('loft'), 'locator' : pm.createNode('locator') } def createConnections(self, *args): ## Connect our main object's (where we selected our edges from) world mesh information ## To our inputMesg of our MeshEdgeNode, this matches info to our new curves. self.main['meshObject'].worldMesh.connect(self.node['meshEdgeNode1'].inputMesh) self.main['meshObject'].worldMesh.connect(self.node['meshEdgeNode2'].inputMesh) ## Connect both our meshEdgeNodes to our loftNode, this completes our loftNode self.node['meshEdgeNode1'].outputCurve.connect(self.node['loftNode'].inputCurve[0]) self.node['meshEdgeNode2'].outputCurve.connect(self.node['loftNode'].inputCurve[1]) ## Connect our loftNode Output Sruface information to our ptOnSurface nodes input ## This allows us to get the information from this surface and plug it into our 4x4 Matrix self.node['loftNode'].outputSurface.connect(self.node['ptOnSurfaceIn'].inputSurface) ## Connect the Normalized Normals (X,Y,Z) to the first row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedNormalX.connect(self.node['matrixNode'].in00) self.node['ptOnSurfaceIn'].normalizedNormalY.connect(self.node['matrixNode'].in01) self.node['ptOnSurfaceIn'].normalizedNormalZ.connect(self.node['matrixNode'].in02) ## Connect the Normalized TangentU (X,Y,Z) to the second row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedTangentUX.connect(self.node['matrixNode'].in10) self.node['ptOnSurfaceIn'].normalizedTangentUY.connect(self.node['matrixNode'].in11) self.node['ptOnSurfaceIn'].normalizedTangentUZ.connect(self.node['matrixNode'].in12) ## Connect the Normalized TangentV (X,Y,Z) to the third row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedTangentVX.connect(self.node['matrixNode'].in20) self.node['ptOnSurfaceIn'].normalizedTangentVY.connect(self.node['matrixNode'].in21) self.node['ptOnSurfaceIn'].normalizedTangentVZ.connect(self.node['matrixNode'].in22) ## Connect the surface positions (X,Y,Z) to the fourth row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].positionX.connect(self.node['matrixNode'].in30) self.node['ptOnSurfaceIn'].positionY.connect(self.node['matrixNode'].in31) self.node['ptOnSurfaceIn'].positionZ.connect(self.node['matrixNode'].in32) ## All of the above will be processed by the decomposed matrix node to output what we need. ## Connect the 4x4 Matrix output to our decompose matrix Input self.node['matrixNode'].output.connect(self.node['decomposeMatrix'].inputMatrix) ## Now that our decompose matrix node has our correct information, we can connect the -- ## rotate and the translate information to our offset locator group node we created earler, We're done! self.node['decomposeMatrix'].outputTranslate.connect(self.node['locator'].getParent().translate) self.node['decomposeMatrix'].outputRotate.connect(self.node['locator'].getParent().rotate)

Now that we've made all our vital connections for each node, we can run through the main section, where we start to define variables and set up the main settings for each node we created earlier.

Obviously we're performing everything above, based on a selection, so let's start with that, in our __init__ function, which is the main section of this plugin, we'll define and setup everything we need to.

To get the selection, we can use the ls command derived from maya.core.

selection = pm.ls(sl=1, flatten=1)

Flatten will just store our selection in it's own index, rather than storing things as merged arrays.

Now that we have our selection, we can define our three main variables, we'll need to get the object that the edges selected belong to, and also the edge indices for each edge selected. We can prefix our variable names with 'self.', this allows as to access these variables from each function from any scope in our class, this is very very handy.

So let's start by getting our meshObject. Inside our selection variable, we should have two edges, something similar to this when we return it.

# Result: [MeshEdge(u'pSphereShape1.e[287]'), MeshEdge(u'pSphereShape1.e[307]')] #

With this result, we can see our edge index's, as well as our object name's shape. So, let's dive in! We'll create another dictionary to access this information later on.

self.main = { 'meshObject' : selection[0].node().getParent() }

By running the function node on the unicode string of the selection, we can convert this to a readable pymel node. This makes it very easy for us to get the parent shape.

So we're accessing the first index of selection with selection[0] which would equal to:

# Result: MeshEdge(u'pSphereShape1.e[287]') #

We could go through and split apart the string, which is what I've seen in many cases that people do, this works just fine, however it's ugly, not easy to read and Pymel almost always has an alternative.

# Result: u'pSphereShape1' #

Awesome, now that we have our objects unicode shape, once wrapped in our PyNode, we get this:

# Result: nt.Mesh(u'pSphereShape1') #

Now we have our mesh object of the shape! So let's get it's parent using .getParent() which will output:

# Result: nt.Transform(u'pSphere1') #

That's it for our mesh object, I'll show you how I've seen most people get this information, and how I've found through the pymel docs, the below is using the split function coupled with a PyNode wrapper. It's ugly right?

self.meshObject = pm.PyNode(selection[0].split('.')[0]).getParent() self.edgeIndex1 = int(selection[0].split('[')[1].split(']')[0]) self.edgeIndex2 = int(selection[1].split('[')[1].split(']')[0])

Or, a simple, Pymel solution:

self.main = { 'meshObject' : selection[0].node().getParent(), 'edgeIndex1' : selection[0].indices()[0], 'edgeIndex2' : selection[1].indices()[0] }

Simple is better!

After we do this, let's run our three other functions to setup the scene.

## Create all the nodes we'll need for this tool self.createNodes() ## Connect all our nodes together self.createConnections() ## Set all Attributes self.setAttributes()

Lets set up our attributes on each node that needs to be changed.

self.node['meshEdgeNode1'].isHistoricallyInteresting.set(1) self.node['meshEdgeNode2'].isHistoricallyInteresting.set(1) self.node['meshEdgeNode1'].edgeIndex[0].set(self.main['edgeIndex1']) self.node['meshEdgeNode2'].edgeIndex[0].set(self.main['edgeIndex2'])

Setting the isHistoricallyInteresting attribute to 1 will allow us to see the edgeIndex connected to this node in the channel box.

We also se the edgeIndex of each meshEdgeNode we created to our two edge Index we created above. This tells our meshEdge node where/what to gather information!

Now let's move onto our loft node.

self.node['loftNode'].reverseSurfaceNormals.set(1) self.node['loftNode'].inputCurve.set(size=2) self.node['loftNode'].uniform.set(True) self.node['loftNode'].sectionSpans.set(3) self.node['loftNode'].caching.set(True)

First we reverse our surfaceNormals, then we set the size of the inputCurveArray to 2, then we make sure we're set to uniform, make our loft have 3 spans, and turn caching on, caching will greatly speed up this constraint.

Now we can set up our pointOnSurfaceInfo attributes.

self.node['ptOnSurfaceIn'].turnOnPercentage.set(True) self.node['ptOnSurfaceIn'].parameterU.set(0.5) self.node['ptOnSurfaceIn'].parameterV.set(0.5) self.node['ptOnSurfaceIn'].caching.set(True)

First we make sure that we're set to percentageMode, this makes our U and V parameters think as a percentage rather than a unit value. We then set our U and V parameters to 0.5 (50%), and turn caching on here too.

Guess what, we're done! Let's link everything together!

import pymel.core as pm class SimpleRivet(): def __init__(self): selection = pm.ls(sl=1, fl=1) if (len(selection) == 2 and isinstance(selection[0], pm.MeshEdge) and isinstance(selection[1], pm.MeshEdge)): ## Now both our selections are edges, so let's continue! self.main = { 'meshObject' : selection[0].node().getParent(), 'edgeIndex1' : selection[0].indices()[0], 'edgeIndex2' : selection[1].indices()[0] } ## Create all the nodes we'll need for this tool self.createNodes() ## Connect all our nodes together self.createConnections() ## Set all Attributes self.setAttributes() else: ## The selection is not two edges, tell them no! pm.warning('Please make sure you select two edges only.') def setAttributes(self): ## Set attributes on our MeshEdgeNodes self.node['meshEdgeNode1'].isHistoricallyInteresting.set(1) self.node['meshEdgeNode2'].isHistoricallyInteresting.set(1) self.node['meshEdgeNode1'].edgeIndex[0].set(self.main['edgeIndex1']) self.node['meshEdgeNode2'].edgeIndex[0].set(self.main['edgeIndex2']) ## Setup our loft node, caching improved performance alot self.node['loftNode'].reverseSurfaceNormals.set(1) self.node['loftNode'].inputCurve.set(size=2) self.node['loftNode'].uniform.set(True) self.node['loftNode'].sectionSpans.set(3) self.node['loftNode'].caching.set(True) ## position the surfaceInfoNode in the absolute center position with cacheing self.node['ptOnSurfaceIn'].turnOnPercentage.set(True) self.node['ptOnSurfaceIn'].parameterU.set(0.5) self.node['ptOnSurfaceIn'].parameterV.set(0.5) self.node['ptOnSurfaceIn'].caching.set(True) def createNodes(self, *args): self.node = { 'meshEdgeNode1' : pm.createNode('curveFromMeshEdge'), 'meshEdgeNode2' : pm.createNode('curveFromMeshEdge'), 'ptOnSurfaceIn' : pm.createNode('pointOnSurfaceInfo'), 'matrixNode' : pm.createNode('fourByFourMatrix'), 'decomposeMatrix' : pm.createNode('decomposeMatrix'), 'loftNode' : pm.createNode('loft'), 'locator' : pm.createNode('locator') } def createConnections(self, *args): ## Connect our main object's (where we selected our edges from) world mesh information ## To our inputMesg of our MeshEdgeNode, this matches info to our new curves. self.main['meshObject'].worldMesh.connect(self.node['meshEdgeNode1'].inputMesh) self.main['meshObject'].worldMesh.connect(self.node['meshEdgeNode2'].inputMesh) ## Connect both our meshEdgeNodes to our loftNode, this completes our loftNode self.node['meshEdgeNode1'].outputCurve.connect(self.node['loftNode'].inputCurve[0]) self.node['meshEdgeNode2'].outputCurve.connect(self.node['loftNode'].inputCurve[1]) ## Connect our loftNode Output Sruface information to our ptOnSurface nodes input ## This allows us to get the information from this surface and plug it into our 4x4 Matrix self.node['loftNode'].outputSurface.connect(self.node['ptOnSurfaceIn'].inputSurface) ## Connect the Normalized Normals (X,Y,Z) to the first row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedNormalX.connect(self.node['matrixNode'].in00) self.node['ptOnSurfaceIn'].normalizedNormalY.connect(self.node['matrixNode'].in01) self.node['ptOnSurfaceIn'].normalizedNormalZ.connect(self.node['matrixNode'].in02) ## Connect the Normalized TangentU (X,Y,Z) to the second row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedTangentUX.connect(self.node['matrixNode'].in10) self.node['ptOnSurfaceIn'].normalizedTangentUY.connect(self.node['matrixNode'].in11) self.node['ptOnSurfaceIn'].normalizedTangentUZ.connect(self.node['matrixNode'].in12) ## Connect the Normalized TangentV (X,Y,Z) to the third row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].normalizedTangentVX.connect(self.node['matrixNode'].in20) self.node['ptOnSurfaceIn'].normalizedTangentVY.connect(self.node['matrixNode'].in21) self.node['ptOnSurfaceIn'].normalizedTangentVZ.connect(self.node['matrixNode'].in22) ## Connect the surface positions (X,Y,Z) to the fourth row of the 4x4 Matrix Node self.node['ptOnSurfaceIn'].positionX.connect(self.node['matrixNode'].in30) self.node['ptOnSurfaceIn'].positionY.connect(self.node['matrixNode'].in31) self.node['ptOnSurfaceIn'].positionZ.connect(self.node['matrixNode'].in32) ## All of the above will be processed by the decomposed matrix node to output what we need. ## Connect the 4x4 Matrix output to our decompose matrix Input self.node['matrixNode'].output.connect(self.node['decomposeMatrix'].inputMatrix) ## Now that our decompose matrix node has our correct information, we can connect the -- ## rotate and the translate information to our offset locator group node we created earler, We're done! self.node['decomposeMatrix'].outputTranslate.connect(self.node['locator'].getParent().translate) self.node['decomposeMatrix'].outputRotate.connect(self.node['locator'].getParent().rotate) SimpleRivet()

Notice at the end I've added RivetSimple(), this runs our class and performs the tasks necessary! Remember to select your two edges!

There we have it, we don't have any error checking, it's not smart enough to filter out other components, but you get the idea and you can expand on this from here. I'm just trying to teach you the basics of this tool!

The advanced version of this tool can be found here shortly, I'll add a download link to both the simple and the advanced version, please bug me if you think I haven't updated this section and I'll get back to you straight away!

Email me at [email protected]

#python #pymel #maya #rivet #plugin #api

Random Object Scatter - PyMel Plugin

I have re-written my scatter script for Maya as I started to use it in production, realising it really wasn't what I was after, so I decided to re start this little script, here's what she looks like:

And in the advanced tab:

As you can see, this one is very different from my last scatter script, where it had many limitations including:

Rotation

Scale

Limited number of copies

Additional position values

I spent my main time, focusing on true randomness, rather than just picking a vert and snapping the object to it (what the old version did)

This one, I dug a lot further, using Maya's API and a combination of Pymel, I was able to scatter the object within the objects bounding box (min-max) and find the closest point on the surface, this insured that not only is the object positioned anywhere, but also that randomness look I was after, not the grid type scatter effect.

I also focused more on presentation of the UI, there's nothing worse than opening someones script, and being like 'whoooaaa' HOW DO I USE THIS SH$T!

SO, I put all the core ui elements on the first tab, which are all fields that must be used to get the script to work, then all the optional fields on the second, I also made the main function button in green, to separate it from the rest and make it nice and distinguishable that you need to press it to complete or run the script.

In the past, I've always created my UI layouts with QT DESIGNER, it's still a very nice way, simple and fast to create a UI for Maya, however this time I wanted to create it myself, mainly so that when the time comes, I do actually know how to write the UI if need be.

But, I'll stop rambling now, here's the key features of each field in order:

Setup Tab:

Prefix - Allowing you to easily prefix your new objects & it's hierarchy

Distribute Objects(s) - You can select multiple objects here, these are the objects you wish to scatter/distribute on your target mesh, each iteration it will pick one of your object(s) randomly and scatter it.

Target - This is the destination mesh, where you want to scatter your objects to.

Copies - This is the number of copies you want to create, if you choose 10, you will get 10 random objects scattered on your target.

Progress - Updated view tells you how long your script has to complete.

Advanced Tab

Copy Options - Duplicate - This option will just create a duplicate of the selected object.

Copy Options - Instance - This option will create an instance of the selected object, meaning if you change something on the original, the others will be effected as well.

Rotation Options - Normals - You can make each object follow the orientation normals of it's position relative to the closest vertex. This is nice for scattering objects nicely across a surface with automated flow rotation.

Rotation Options - Original - This option will just match the objects original rotation, this is handy if you don't want the script to touch the rotation values.

Rotation Options - Random - This option will drop down another frame, where you can set min and max - or from and to - values that the script will grab a random values between the two values per axis, very handy if you only want to rotate an object along a certain axis.

Position Options - Follow Vertex - This option adds more of a 'grid' effect if your surface is modelled in such a fashion, but this might just be your desired effect.

Position Options - Random Position - This option will just pick a random surface position and stick there, this adds a more non-linear effect to the scatter.

Apply Random Scale to distributed Objects - As it's name suggests, this will pop down another frame, where you can set min and max - or from and to - values that the script will grab a random values between the two values per axis, very handy if you only want to scale an object along a certain axis, or just have variant sizes.

Stick scattered objects to target mesh - With this option, you can deform the target mesh and the scattered objects will still retain their position on the surface, this is cool for animated characters, for example you may have a shark with a bunch of sucker fish on him, no matter where you move or deform the character, the fish would still stay in the correct position.

I'll upload a working demonstration of this tool soon with a scene I'll be building, I'll demonstrate it's power there! If you'd like to have a look at this tool prior to this, please email me at [email protected] and I'll send it over :)

#pymel #maya #api #scatter #distribute #ui #plugin #python #math #random

Calculating the angle between vectors in Maya

Recently, I was asked this question by a friend, so I decided to do some digging and write it up for him, so I figured why not explain it in detail for others? Let's say we have two joints, each originating from a single point in space, like so:

In this example, we'd be needing to calculate something like this:

Say we wanted to get the angle between these two joint 'arms', how can we make this dynamically work on any given objects? Obviously our goal answer will be 90 degrees as its completely square, however just because we know that doesn't mean the compooooter does! First, let's import some modules that we will need: I'm working with Pymel, it's just my preferred method, although everything I'm writing is easily translated back to standard python commands.

import pymel.core as pm from math import acos, sqrt, pow, degrees

Once we've imported our modules, we need to get the positions of each A, B, and C values:

To do this, we can use the trusty xform command... (I hate it) or we can be awesome and use Pymel

//With Xform (ew) a = pm.xform('joint_A', q=1, ws=1, t=1) b = pm.xform('joint_B', q=1, ws=1, t=1) c = pm.xform('joint_C', q=1, ws=1, t=1) //With Pymel (sexy) a = PyNode('joint_A').t.get() b = PyNode('joint_B').t.get() c = PyNode('joint_C').t.get()

The above just get's the vector co-ordinates of each joint in world space. With these values, we will be able to calculate the hypotenuse, opposite and the adjacent lengths using the following formula:

The above formula will calculate the the distance between two vector co-ordinates, so lets get going! To calculate the distance of the hypotenuse (longest side), in this example, the Hypotenuse would be A to B. SO:

hypotenuse = sqrt(pow(a[0] - b[0], 2) + pow(a[1] - b[1],2) + pow(a[2] - b[2],2))

It looks scary, but it's really quite simple, now we just have to do this again 2 more times to calculate the adjacent and the opposite, but instead of duplicating the same code for essentially the same purpose, let's create a function.

def getDistance(a,b): return sqrt(pow(a[0] - b[0], 2) + pow(a[1] - b[1],2) + pow(a[2] - b[2],2))

Now we can make our variables look pretty! WOO PRETTY! Notice that we're passing through the variables created above with xform.

hypotenuse = getDistance(a, b) opposite = getDistance(a, c) adjacent = getDistance(b, c)

Now that we've done this, we can get to the tricky part, using this formula:

The above looks scary too, but all it's doing is calculating the angle in radians, this equation may be different in your case, please make sure you look into the Law of Cosines to see which law suits you best. So to convert this formula into Maya :

angleInRadians = acos((pow(adjacent,2) + pow(opposite,2) - pow(hypotenuse,2)) / (2.0 * opposite * hypotenuse))

Now that we have our angle, let's be real and convert this to degrees!

print degrees(angleInRadians) Returns >> 90.0

Isn't that awesome? So to summarise and condense, I've compiled the above into a small re-usable script:

import pymel.core as pm from math import acos, degrees, pow, sqrt def getDistance(a,b): return sqrt(pow(a[0] - b[0], 2) + pow(a[1] - b[1],2) + pow(a[2] - b[2],2)) def getAngle(sideA,sideB,center): a_end = PyNode(sideA).t.get() b_end = PyNode(sideB).t.get() center = PyNode(center).t.get() hypotenuse = getDistance(a_end, b_end) opposite = getDistance(a_end, center) adjacent = getDistance(b_end, center) angleInRadians = acos((pow(adjacent,2) + pow(opposite,2) - pow(hypotenuse,2)) / (2.0 * opposite * hypotenuse)) return degrees(angleInRadians) print getAngle('joint_1', 'joint_2', 'joint_center')

If you have any further question, please don't hesitate to email me [email protected]

#python #math #maya #angles #degrees #distance #vector

I've spent a huge amount of time developing a new project called 'SASSY GRIDS'. It's an automated version of the 960 grid system for css. Written in SCSS/SASS, it's a pre processed version of your normal css file which will automatically calculate/generate absolutely everything you will need to design any web layout. It's easily the biggest project I've written, really happy with the end result, and it's so easy to write! Shannon

#scss #sass #css

I've been meaning to create this tool for quite some time now. Inspired by Blender's 'ToSphere' function. Maya lacks by default many tools that could be handy, I really did like this function within Blender, so I figured that I'd attempt to create something similar for Maya. This is also the first tool I've written using pymel, it's definitely a much easier language. It has many useful features as shown in the video. The force behind it, is this little equasion: Here's a few little features of this script: 1. Averaging the selection of objects or components or in conjunction with each other. 2. Converting cube like shaped to spherical shapes in seconds. 3. Can perform this task in loca space, world space and object space. 4. Options for flattening the selection for a straighter result. It's very easy to use, and quite handy. Please let me know if you'd like a copy of this script. (Blender's version: http://wiki.blender.org/index.php/Doc...) Shannon

#python #pymel #maya #api

Just finished another tool for Maya, there are many tools out there that do just this, but I wanted to add my own spin on the tool. It does some pretty swell things. 1. Specify a prefix for all duplicated objects. 2. You can choose duplicate or instanced copies. 3. Add random values for scale and rotation 4. Each object follow the objects normal directions. 5. Choose how many copies (limited to how many verts it has) 6. You can select multiple objects to be copied 7. For the target, it can be either vertices or an object It's a very useful script when building scenes etc. Please let me know if you'd like to give it a try :) Shannon

#maya #python #script #animation

Recently I was asked by a client to produce a template for a YouTube channel where they're constantly uploading DJ tracks so they wanted a decent background/video to go with whatever they wanted to upload. So I figured what better way to do that than with a responsive audio/visualisation. This theme is highly customizable and turned out great. Would love some feedback! Cheers, Shannon

#animation effectsafter effects3d2dpulsevisualisationaudiovideoadobemusicdjsoundAdobe After Effects (Software)Music Video (Product Line)

I've been working on a custom python tool set for quite some time, but the most recent tool I've created, uses the soft selection of the components, and paints weights to the deformer for a smooth and exact fall off with the click of a button. The final result is pretty good, I'm not 100% happy with the tool, there's a few little bugs to be fixed. A few more ideas I'd like to chuck in, but for now I'm happy to release what I've completed so far. Features: - Optional control colours controlled by a custom display layer - Global and local control scales - Global visibility - Option to work with clusters or SoftMod - Any component(s) can be selected, rather than maya's limition of one component type. - Works with Curves, Surfaces or Polys - Option and control to be able to easily parent into a rig - Batch processing based on selection (100 deformers can be applied with one button) - Multiple falloff values are still painted regardless of the selection - Cluster or softMod weights can still be repainted for tweaking - 100% scaleable for rig purposes - Custom icon for Shelf Features for next release: - Mirror option for selected controls over X,Y or Z - Patches for batch processing, it's not 100% pefect - Batch parenting option, at the moment it's one by one for parenting - Offset position controls for animation controllers - List that stores the current deformers in the scene. You'll be able to select and edit them from this list. Please let me know your feedback or if you have any suggestions for this tool Shannon

#soft #deformer #mel #python #cluster #softmod

Added a few new scripts to my products section of my website. http://www.shannonhochkins.com/products Go have a looksie! The $5 price, is simply if you feel like donating the money, you do not have to pay for these scripts! Scripts v001 In this free bundle you'll receive: - Maya 2012 Render window bug FIX (no UI) - Auto ARM FKIK stretchy rigger - Incremental saver - Locator snap tool for rigging purposes (no UI) - Limit transformation tool (no UI) Here's some more detailed explanations of the scripts Maya 2012 Render window bug FIX You'll notice sometimes when you click on the render window button, that maya believes that the window already exists, but it either doesn't, or all the buttons are missing and you can't actually see any renders or do much at all. This resurrects this problem! Auto ARM FKIK stretchy rigger This will create a full FKIK arm setup for any character, it's well rigged, easy to use and has multiple controls. Very easy to use. Incremental Saver This script will automatically figure out what version you're upto with you scene file, and rename it incrementally by 1 with a padding of 4. Also has a few other options, but definitely helps! Locator snap tool for rigging purposes (no UI) This tool is pretty handy for things like facial rigs, if you need to reset a tool back to it's default position, having to select it, then "0" out it's transforms can be a little time consuming. So I wrote this script to simply this process, with all the controls at their default position, select them all, just simply run the script and it will place a locator at the center of the control and reference it. It will now allow you to snap the control back to it's original position which is also it's 0 transform location. Limit transformation tool (no UI) Setting limitations on multiple controls that have exactly the same limitations can be very time consuming, so i wrote this simple script that will do it for all the selected controls. Just set the variables limits, and run the script and bam! They can't go any further than the limitations! Click here to download the scripts

#maya animation scritps python mel

There's actually a #Toystory theme park in #hongkong. kkfjwjsbsbdkijrkgogkebdbfb (Taken with instagram)

#hongkong #toystory

So happy with the turn out to my festival! Www.blazenbeats.com (Taken with instagram)

Here's my Showreel for 2011, been through an immense amount of interviews lately but sadly they're all for jobs toward the end of the year so just kicking back and enjoying life at the moment! Absolutely loved working on Happy Feet 2, was an absolute ball, can't wait to get back into films and TVC's. Sorry I haven't updated in a while! been very busy, I now own my own event management/promotion company, so I'm keeping myself entertained 24/7, on the side I have been designing a few websites here and there. visit http://www.shannonhochkins.com/web to see my latest few I have added. Cheers, Shannon

haven't updated in a while, figured id post the small changes that i did, bumps still a bit too high, other than that. im still in setup stage for my character so not much of an update!

#jinglez #animation

cirtz? im happy with this lighting, all thats left to tweak is add in the indirect lighting to comprehend the physical, and tweak the glass material and liquids a little more. lookin cool tho!

#jinglez #animation

Trending Blogs

Recently Viewed Blogs

Shannon Hochkins