Render Curve Compound Update.

The StrandDeform is an attribute used to “extrude”  ICE strands. It was on my to do list to add it in my render curve compound to reduce the number of particles needed to create a curve. But, as I don’t spend too much time in ICE, I never add it. Fortunatly, Ahmidou Lyazidi, a french director at la station animation add this feature and send it too me. He also debug the U array needed to create the strands (since XSI 7.01, the array initialisation doesn’t work exatly the same way than in XSI 7.0).

You can download the Render Curve Compound 1.2 here.

Making Waves: The 14 Days of Vincent Laforet

Here is what you can do with some little toys like a Red One and a 5D Mark II cameras. You also need to be in Hawaii with a very good surfer…

http://vincentlaforet.smugmug.com/gallery/6961015_exAjb/1/470408047_95AKN/Large

An Expression Class for the XSI SDK (part 2)

Now that you know the purpose of the Expression() object, I’m going to show some examples. I hope you will find it easier and more elegant than the classic string concatenation (and also I hate the word “konkatenation”).

First example : We really need to clamp a null position inside a cube  to create the best character rig ever done (simple as that).

There is no built in clamp function in XSI (I know, it sucks…). Instead we can use a conditional expression or a combination of MIN and MAX expressions. On top of that, you add the script concatenation and it will looks like a very ugly  thing. Fortunately, the brand new Expression object is there to save your mental health ! Lets code now :

#First you import the xsi_expr module and get the Expression class
#(I presum that you already know  a way to set a path to a module from xsi)
import xsi_expr
from xsi_expr import Expression
#Then the ‘exotic’ XSI python things
xsi = Application
xsilog=xsi.LogMessage

#Lets build a simple  implicit cube and a null
cube = xsi.ActiveSceneRoot.AddGeometry(“cube”)
nullInsideCube = xsi.ActiveSceneRoot.AddNull(‘inside_cube’)

#Then the null x, y z positions parameters 
nullPosx = nullInsideCube.posx
nullPosy = nullInsideCube.posy
nullPosz = nullInsideCube.posz 

#Here is the first Expression Object to get the cube limits from its length.
cubeLimitMax=Expression(cube.length)
cubeLimitMax.div(2)
#Then we create the min limit from the max limit like this:
cubeLimitMin=Expression()
cubeLimitMin.sub(cubeLimitMax.Value)

#Then we can create the expressions objects for the position x, y ,z of the null. 
posInCubeX = Expression()
posInCubeX.clamp(nullPosx, cubeLimitMin.Value, cubeLimitMax.Value)
posInCubeY = Expression()
posInCubeY.clamp(nullPosy, cubeLimitMin.Value, cubeLimitMax.Value)
posInCubeZ = Expression()
posInCubeZ.clamp(nullPosz, cubeLimitMin.Value, cubeLimitMax.Value)

#And finally apply the expressions to the parameters
nullPosx.AddExpression(posInCubeX.Value)
nullPosy.AddExpression(posInCubeY.Value)
nullPosz.AddExpression(posInCubeZ.Value)

#if we need to see an expressions value we can use the
#xsiShow method like this : 
posInCubeX.xsiShow()

# INFO :
#MIN( MAX( inside_cube.kine.local.posx,  - cube.cube.length / 2 )
#, cube.cube.length / 2 )         

#but you can also log a message like this
#xsilog( posInCubeX.Value)
… 

Here is an other exemple just to show how to use the pow and fit methods : 

import xsi_expr
from xsi_expr import Expression
xsi = Application

#Lets build two nulls

 

 

A = xsi.ActiveSceneRoot.AddNull(“A”)

B = xsi.ActiveSceneRoot.AddNull(“B”)

#Position x from B is the power of position y from A.

Bposx = Expression()

Bposx.pow(A.posy, 2) 

#Apply the expression

B.posx.AddExpression(Bposx.Value)

#Rotation z from A is drived by rotation z from B

#But it is  ”re-scaled” between 0 and 90 when B rotate between 0 and 360.

Brotz = Expression()

Brotz.fit(A.rotz, 0, 360, 0, 90)

#Apply the expression

B.rotz.AddExpression(Brotz.Value)

             

#Lets see our expression :
xsilog( Brotz.Value )
# INFO :
#cond( A.kine.local.rotz<0, (A.kine.local.rotz/0)
#*0, (A.kine.local.rotz/360)*90 )

#Now try to create this expression without the Expression Object !

 

If you are not exhausted by this post, you can try the module on your own here.

Happy scripting !

Cheers

 

 

Guillaume Laforge

An Expression Class for the XSI SDK (part 1)

If you often need to apply some expressions on xsi parameters through scripting, maybe you will find this python class usefull…

Expressions are fast to compute and relatively easy to write from the xsi expression editor…but , as I often write expressions from a script, I often lost too much time debugging my concatenation errors. For example if you need to apply an expression from a script , it could look like this pseudo code :

• parameterA = ObjectA.aMasterParameter
• parameterB = ObjectB.aMasterParameter
• parameterC = ObjectC.aSlaveParameter
• theExpression = “ctr_dist( “+ParameterA.FullName+”. , “+ParameterB.FullName+”. )”
• parameterC.AddExpression( theExpression )

As you can see, writing a simple distance expression between two objects is not fun. It is obvious that it is much more difficult to apply some
formula on strings than on vectors for example. So I create the Expression object. From this object, you can call methods with the same name than the corresponding expression. Here is a little sample :

• parameterA = ObjectA.aMasterParameter
• parameterB = ObjectB.aMasterParameter
• parameterC = ObjectC.aSlaveParameter
• theExpression = Expression()
• theExpression.ctr_dist(ParameterA , ParameterB )
• parameterC.AddExpression( theExpression.Value )

I recently wrote this class in python just for my needs, and so I added the expression methods “on the fly”. Now, the idea is to put the python source on my blog. If you find this module usefull and if you add your
own expression to the methods, please send me the update ! Maybe next time I will need your expression .

So here is the python module to define the Expression Object. If you are not using python for your xsi scripts, you can put my class in a python command and call it from your vbs/js scripts.
More info here : http://softimage.wiki.softimage.com/index.php/Python_(XSISDK)#Creating_your_own_Modules

Now it is late, I will continue this post later to show you other examples of this python class. See you soon !

Some new RenderChannels Compounds

Thanks to Robert Lenz  for those two new compounds  :

misss_Fast_Shader and
mi_Metallic_Paint

Both use the same logic code than the  mia_x RenderChannel compound, so it was really easy to understand their workflow for me .