The video below will give you a rundown on how to activate the feature within the context of a really simple example of getting a ball to float and bounce around on the top of a particle fountain.

Please note that ICE Kinematics are an unsupported feature that you would be using at your own risk. I’ve had a fair bit of success with it but if it goes boom and you loose time and assets, I will say: I told you so!

Have fun!

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

By the way… The line you have to add in the setenv.bat file that you can’t read in the video is:

set XSI_UNSUPPORTED_ICE_KINEMATICS=1

  mklink /D d:\alias_location  d:\actual\location\of\directory

The /D stands for directory link, because file links are also supported. Even better, the link can be to a remote location.

  mklink /D d:\alias_location  \\server\share

Naturally, if you only wanted a drive letter shortcut, the old ‘subst‘ command still works.

You all remember the idea of a proxy parameter where editing a parameter in a custom PPG (lets call this one the source) will in fact be changing another elsewhere in the scene (this one we will call the target). Extend this idea to a selection where selecting a source will in fact ‘transfer’ the selection to another object. This could be useful, among other cases, in a rigging scenario.

As it was suggested in the thread, there are many use cases for a functionality like this that can be addressed with native XSI tools and methodologies but nonetheless, I felt like there might be some cases where an actual proxy select could be useful. So I cooked one up for Bryan, and here it is.

Select one or more targets and then go to Get -> Property -> Proxy Select and then pick one or more source objects. From then on whenever you select a source object, it will unselect itself and select the targets instead. There is some sanity checking in there to try and avoid dependency loops and the like, just in case.

There are also three menu items in the MCP Select menu that will toggle proxy select functionality in six different ways.

• Toggle on proxy select for all objects – when nothing is selected
• Toggle off proxy select for all objects – when nothing is selected
• Toggle/Inverse proxy select state for all objects – when nothing is selected
• Toggle on proxy select for selected objects
• Toggle off proxy select for selected objects
• Toggle/Inverse proxy select state for selected objects

I can already hear you asking: “How can I select a proxy select source to toggle it’s functionality if it is already on and automatically transfers it’s selection?”

Well,

• If it is only one object you wish to toggle you can go directly to it’s Proxy Select custom property.
• If you wish to act on multiple objects with these toggle menus, you can multi select the objects and toggle them all together. When multiple objects are selected, no selection transfer takes place.
• This also means that you can multi select a proxy select source with any other object and then use the menu items, any object that isn’t a proxy select source will be safely ignored.

And then came Thiago

One of the people involved in the thread was Thiago Costa from Nervo.tv. He is actually the one who suggested an approach for creating the Proxy Select plugin in the first place. Well, about the same time I had sent Bryan my first draft Thiago posted his version. I said it in the thread and I will say it again, it is very nicely executed.

One of the things he did is that he anticipated the user’s needs and thought for a second about what you would like to do with the resulting select.

Something that happens to often (well for me anyway), and especially in the heat of production, is that we fail to properly establish requirements.

These requirement will inevitably change.

When the first wave of requirements is put down on paper some time should be spent trying to anticipate the user’s needs as well as possible future requirements. Even if these extra features aren’t initially implemented, having this foresight will allow the resulting code to better accomodate change.

Downloads

Check out the thread at Softimage|Net for Thiago’s version.

Download my version from here.

The first step to take, was to decipher the the file structure of the FG and Photon maps. Since the files are written in binary, this wasn’t that easy. But with the help of UltraEdit, a HEX editor for Windows, and some trial and error, the main file structure mystery was unveiled. Here is an example of how this looks like in a FG map:

The blue marked part is the file type and the version of MentalRay. The green part is a 32 bit integer value which is the total FG Point count. Next comes the FG Point itself. One FG point is represented in 104 bytes in total. That’s the first bright block. The first 12 bytes are the x, y and z coordinates in 32bit floating point numbers. And so on…

Final Gathering maps have another structure than Photon maps and thus it took me twice the time to build the file structure.

Once this was done, I had a little look into OpenGL programming and had a little talk to Andrea Interguglielmi. He helped me with the Logic behind the connection between XSI and OpenGL.

What this tool does is in fact pretty simple. When the plugin is loaded, it registers a new DisplayCallback and allocates some basic memory. Then, after you select a map and press on the “Show Map” button, it reads the chosen file and creates an array of position and color values which are stored in the memory and then displayed through some basic OpenGL functions.

With this tool you have the ability to view your saved FG and Photon maps in your 3D-Viewport of XSI. After installation, you can find it under Get-> Property-> JV_MapMiner. It is provided as is and nobody is responsible in any way for any possible damage.

I hope this tool can help people to optimize their renderings and make their lives a little bit more comfortable.

You can download the .xsiaddon (tested on XSI 5.x and 6.1) and a demo project with one FG map, one GI map, one Caustic map and one GI+Caustic map combined (27mb).

You are welcome to send me bug-reports or suggestions.

FG Quicktime
GI Quicktime
Caustics Quicktime

Buddha 3D-Model courtesy of the Stanford Computer Graphics Laboratory.

The sRGB Standard

The sRGB colour space is based on the monitor characteristics expected in a dimly lit office, and has been standardised by the IEC (as IEC 61966-1-2). This colour space has been widely adopted by the industry, and is used universally for CRT, LCD and projector displays. Modern 8-bit image file formats (such as JPEG 2000 or PNG) default to the sRGB colour space.

A value in the sRGB colour space is a floating-point triple, with each value between 0.0 and 1.0. Values outside of this range are clipped. An sRGB colour from this [0, 1] interval is commonly encoded as an 8-bit unsigned integer between 0 and 255.

The pivotal fact to remember about sRGB is that it is non-linear. It roughly follows the curve y = x ^2.2, although the actual standard curve is slightly more complicated (and will be listed at the end of this article). A graph of sRGB against gamma 2.2 looks as follows:

This mapping has the nice property that more resolution is given to low-luminance RGB values, which fits the human visual model well.

The Gamma Function As An Approximation

As can be seen by the above graph, the sRGB standard is very close to the gamma 2.2 curve. For this reason, the full sRGB conversion function is often approximated with the much simpler gamma function.

Please note that the value associated with the word gamma is the power value used in the function y = x^p. Unfortunately gamma is often associated with brightness, which is not exactly what it is doing. The full [0, 1] interval is always mapped back onto the full [0, 1] interval.

What Maths Work In This Colour Space?

In general your lighting pipeline should be done in linear space, so that all lighting is accumulated linearly. This is the approach taken in many film pipeline, and is the only way to ensure that you are being physically correct.

However, assuming that the gamma function approximation is good enough, you can still perform modulate operations. In this case we have some constant A that we wish to modulate our sRGB source data x with, and store the result in sRGB as y. In linear space this would be written as:

y^2.2= A x^2.2 = ( A^1/2.2 x )^2.2

Since we are working only in the [0, 1] interval, we can remove the power from both sides and work in the sRGB space itself. In which case:

y = A ^1/2.2 x

So if we convert our constants into sRGB, then modulate operations can still be performed. However, there are only very few operations that work this way. Additive operations (which are used in additive lighting models, or for alpha-blending) cannot be reformulated to work in a gamma 2.2 space, simply because the space is non-linear. If you wish to have a correct additive lighting model, then you have to work in a linear space, which will mean that you need a higher-precision framebuffer to at least match the low-luminance granularity of sRGB.

sRGB to linear RGB: rgb (sRGB), RGB (linear RGB)

This is commonly approximated as X = x ^2.2 for all channels.

linear RGB to sRGB: RGB (linear RGB), rgb (sRGB)

This is commonly approximated as x = X ^1/2.2 for all channels.

Ok But How To Do That in XSI ?

Before the release of XSI v6, we could change the ouput gamma of Mental ray and match approximately the sRGB by using a gamma of 2.2 ( put 1/2.2 in the active effect tab). In version 6 this option is missing unfortunately but don’t worry there are others third party addon that can do the job for you.

I wrote one of them and you can find them here.

This addon include two shaders. A texture node that convert sRGB image in linear space and a lens shader that convert linear render to sRGB color space.

These shader are intended to be used in a context where you don’t output anything in float format. I didn’t try it in this context so you don’t have any warranty.

The idea is to convert every texture that you create in Lin space and convert every render in sRGB space. By texture I mean any images that are not used to drive data such as displacement map, bump map or normal map. I exclude also floating point image which are considered linear defacto.

Let’s see these shader in action

I will first focus on the lens shader and then on the texture node.

As I said we need to watch our result according to the monitor profile (sRGB) so to convert our render we need to apply the lens shader. It’s really easy use add it on the lens shader stack.

My first example is simple. A grid with a phong shader and a light. An area light with a realistic falloff. To do this I am using the D2S_light with a temperature of 6500 K (White). I set the light intensity to get the same result in the red area.

The left picture is rendered as-is in XSI while the other one is rendered with Lin_to_sRGB Lens shader. As you can see the left picture is overlighted. (intensity around 4000) While the right one behave nicely (with an intensity of 750 only).

Note that even the specular from phong shader looks correct. It looks like the reflection of the area light.

My second example is a simple FG scene with 2 spheres and a plane. The plane and one of the sphere got a DGS shader with only a diffuse term set to a neutral gray. The second sphere is fully reflective to see the environment map.

I used an HDR image from Paul Debevec’s website called beach.hdr to light my scene with Final Gathering.

The first test is a render as-is:

As you can see the color of the environement map are more contrast / darker than what we can see in HDR shop. To correct this naturally we will change the exposure but the color will be affected and we will got a more saturated image which is wrong.

If we use the lens shader we go this result:

The result this time is what we expected. The color match to what we can see in HDR shop. We can start to work safely because we got the right illumination.

On my next example I am introducing a texture on the grey plane by plug to the diffuse slot an image node. I am keeping the same HDR illumination and the lens shader.

As you can see the texture is washed out. This doesn’t come from illumination. This wood texture has been generated in sRGB color space. With the lens shader we simply apply an another time the sRGB convertion. What we need is to convert this texture in linear space before the render. It is the purpose of the sRGB_to_Lin texture node. Just plug it between your image node and the diffuse slot and re-render.

As you can see now our texture is corrected and looks natural.

Bonus

If you need to change your setup and include these two node to your existing setup your can use the existing script written by Guillaume Laforge and included in the first archive. It will insert a sRGB_to_Lin node after your image node.

If you have any questions, critics or correction please don’t hesitate : harry.bardak@wanadoo.fr

Edit : Gradient example removed because it seams to confuse more people than it helps. Shaders source code fixed I didn’t realised that this article was read by non XSI users.

It is, of course, more useful than just an example as anyone who’s used Maya’s CommandPort can tell you. The C# example is cleverly wrapped in a timer event, allowing it to run in the background and quietly check for a connection every few seconds. More for reasons of clarity than anything else I’m just going to wrap this up in a function and let someone else decide how best to use it but I will get a little bit into timeouts and how to handle the hang you can get if there’s nothing at the other end.

Python is a really good example of just how sensible it was to use good existing scripting languages rather than writing bad new ones. You not only get the language for free, you also get most of the Open Source community too and with Python that means quite a lot of modules, allowing you to do more stuff than you could shake a stick at in a lifetime of stick shaking.

I’d done stuff like this before in Perl and C but not Python and I was interested in how long it was going to take to do this. As it turned out, around 20 minutes, which is pretty good but more testament to the other thing you get for free with Python – shedloads of free examples – than any skills I may have.

Python is pretty good at wrapping complicated stuff up and making it easy to use and this is no exception. To read something from a port the sequence of events is:

• Create a socket
• Bind to the socket
• Listen on the socket
• Accept the connection
• Read whatever’s being sent from the other end
• Optionally send something back
• Close the connection

This is all fine and dandy, except that if there’s nothing at the other end then the Accept hangs until there is. If nothing ever tries to connect we get a nasty hang that’s not easy to get out of. So we could do with something that can peek at the socket and see if there’s something there. Such a thing is a thing called “select”. In generic terms Select() is used to check any kind of file that’s open for reading to see if there’s something to read and, at least of grownup operating systems, a socket is treated in the same way as a file. We call select() on the socket just after we start listening. If select returns a list that isn’t empty then someone’s knocking at the other end and it’s safe to go ahead. If it’s not we ignore the accept call and just return nothing and bingo! no hang.

And finally, I’ve taken a slightly different slant in executing code to the C# example. It accepts commands to either log a string or run a script file. It seemed more natural to me to run a string than a file, partly because it seems such a pain creating script files all over the place but mostly because I figured if I could run a string then I could do both the other two things with the code in that string.

Here’s the code. You can test it by running the script in XSI and using telnet to connect. Either “telnet localhost 50007″ from the local machine or “telnet machine 50007″ from some other machine. At the telnet prompt type something like jscript|logmessage(“Testing”); will run logmessage(“Testing”) at the XSI end. Enjoy.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

import socket
import select
import re
 
def ReadSocket(PORT, TimeOut=1):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('', PORT))
    s.listen(1)
 
    # is someone knocking at the other end?
    #
    a = select.select([s], [], [], TimeOut)[0]
 
    # someone's there
    #
    if (a != []):
        # accept the connection
        #
        conn, addr = s.accept()
 
        # get data from the socket
        #
        data = conn.recv(1024)
 
        # parse the result
        #
        tokens = re.split('\|', data)
        if (len(tokens) != 2):
            Application.LogMessage("Useage: Language | script code")
            sRet = "Error"
        else:
            sRet = str(Application.ExecuteScriptCode(tokens[1], tokens[0]))
 
        # be polite and send something back
        #
        conn.send(sRet)
 
        # close the connection and return the result
        # of the last command
        #
        conn.close()
        return sRet
 
    # there was nobody there so return false
    #
    return False
 
###############################################################
#
# Testing on port 50007
# with a 10 second timeout.
# You can test this using "telnet hostname 50007" from any other machine
# or "telnet localhost 50007" from this machine
# typing something like 'jscript | logmessage("testing")' will run 'logmessage("testing")' in the remote XSI.
# 10 seconds should be enough time for you to run across the room and kick off a telnet. If you don't
# make it then it'll just time out.
# The connection is closed once the first string has been parsed but you can, if you wish, concatenate
#  commands, as in 'jscript|logmessage("testing")|python Application.LogMessage("Python Testing")'
#
s = ReadSocket(50007, 10)
if (not s):
    Application.LogMessage("Timeout")
else:
    Application.LogMessage("Connected: %s" % s)

My Softimage .pic codec for QuickTime has been updated with a bug fix for a corrupted image issue reported by a few users

For some info on the GUID check out wikipedia and a previous post by Luc-Eric.

There are many ways you can create these identifiers, they are basically just a unique number written in hexadecimal form. Some even advocate taking a preexisting GUID and changing a few characters. Personally I wouldn’t do this, the opportunity for conflict in my opinion is just too great and creating a GUID is too easy anyway. To create a proper GUID on a windows system you can use the guidgen.exe command or many other methodologies but as long as you’re in XSI why shouldn’t XSI be able to create one for you?

Stick the following Python code in a toolbar button and you’ll turn Softimage’s premier tool into an identifier creating machine. Each time you run the script or press the toolbar button, XSI will create a proper unique GUID for you. On top of that it’ll put the identifier in the Windows clipboard so you can paste it into your SPDL file or whatever other place you want it.

1
2
3
4
5
6
7
8
9
10
11
12
13

import pythoncom, win32clipboard
 
# Create Guid
guid = pythoncom.CreateGuid()
 
# Put Guid in clipboard
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardText(str(guid))
win32clipboard.CloseClipboard()
 
# Show Guid
Application.LogMessage(str(guid))

Why should you care about GUIDs? Well Stefano Jannuzzo will have an article on XSIBlog shortly about Phenomenon in the RenderTree that will make you care about Identifiers.

The above code is for Python on Windows. If anyone has alternative versions for JScript, VBScript as well as the Linux platform, please feel free to post them in the comments, I’m positive many people will find them usefull.

For OS X developers, Apple has made QtKit for Objective C developers so that normal people (as normal as a person who choses Object C can be, anyway) can easily add QuickTime support to their app.

At about the same time, for Windows QuickTime 7.0 Apple has done the equivalent and added a new COM/ActiveX Control. This is not to be confused with the control that’s used in the Web Browser, it’s something totally different that is meant to be used in Visual Basic, C#, and C++ and other COM-enabled languages.

This new access to QuickTime is mostly meant for application developers in these programming languages, however it is possible to access these COM objects from ActiveScripting, so this means VBScript, JScript which come with Windows, and others like Python and Perl.

One little known fact is that you can run VBScripts and JScripts at the command-line on any Windows 2000 and XP machine. The command-line intepreter is called “cscript.exe” and is located in your “Windows\System32″ directory. “wscript.exe” is a windowed equivalent which will pop message boxes instead of displaying messages at the command line. If for some reason you don’t have it installed, it’s a free download.

The scripting interface to QuickTime is still largely undocumented, however you can check out the methods and properties with an OLE object viewer. I’ve also found some good examples on the web site for the book QuickTime for .NET and COM Developers , in the (Chapter 8) samples.

Time for some code.

I’ve created a script below which will convert an image sequence to a QuickTime movie.

The only hard part was the issue with codec settings. As you may know from XSI and other products, codec settings are a binary blob of data, and are not suitable to be set with a script, or nice human-readable properties: you have to go through the codec-specific custom user interface. However the QuickTime control does allow to save codec settings into an XML file, to be re-applied later. Again, the data is still not human-editable in this form — the XML file contains Base64 data — you will need to use the codec dialog to change the settings. But at least you only need to pick it interactively once and can re-use the XML file for batch processing.

The first time you run my script, you’ll pick the codec with the dialog box, and these settings will then be saved into an XML file on the C:\ for the next time. Only known issue: the UI for the QuickTime player will apear during the export process, but that shouldn’t cause any problem, the script doesn’t return until the task is done.

QuickTime detects image sequences automatically when you give it an image file with a number in it. To run the script, type something like
cscript jsQTtest.js D:\clock001.pic C:\clock.mov

If you’re playing with the script and get an Unspecified Error on line 21, try manually launching the QuickTime Player manually before running the script.  commenter Nathang wrote:

I fixed the “C:\qttest\qttest.js(21, 1) (null): Unspecified error ” problem by….

//under here:
var qtPlayerApp = WScript.CreateObject(”QuickTimePlayerLib.QuickTimePlayerApp”);

//Add:
WScript.Sleep(7000)

This give quicktime the chance to launch properly

To get access to the “Import Image Sequence” in QuickTime 7.0, normally you need to upgrade to QuickTimePro, but I’ve tested my script after disabling my QuickTime Pro license and it seems to work anyway.

Here is the script… click on the image to download it.
credits : I’ve received some from the QuickTime API mailing list on apple.com to resolve a codec setting issue, and I’ve used the samples from the book above.

This script converts images sequences to movies. It will exit and do nothing if you try to convert a movie to another movie Try changing the call to CreateNewMovieFromImages to CreateNewMovie to do that!

// to run from the command line :
// cscript jsQTtest.js sourcepath, destpath

// Get script arguments
if (WScript.Arguments.Length >= 2)  {
    sourcePath = WScript.Arguments(0);
    destPath = WScript.Arguments(1);
}   else    {
    WScript.Echo("not enough parameters");
    WScript.Quit();
}

// Launch QuickTime Player Application
var qtPlayerApp = WScript.CreateObject("QuickTimePlayerLib.QuickTimePlayerApp");
if (qtPlayerApp == null)    {
    WScript.Echo("Unable to launch QuickTime Player!");
    WScript.Quit();
}

// Get the QuickTime controler
var qtPlayerSrc = qtPlayerApp.Players(1);
if (qtPlayerSrc == null)
    WScript.Quit();
var qtControl =  qtPlayerSrc.QTControl;

// Set up the exporter and have it configured
var qt = qtPlayerSrc.QTControl.QuickTime;

qt.Exporters.Add();
var qtExporter = qt.Exporters(1);

var CodecInfoFileName = "C:\QuickTimCodecInfo.xml";

var FileSystemObject =  WScript.CreateObject("Scripting.FileSystemObject");
var CodecFileInfo;

if ( FileSystemObject.FileExists(CodecInfoFileName) )
    CodecFileInfo =  FileSystemObject.OpenTextFile( CodecInfoFileName );

qtExporter.TypeName = "QuickTime Movie";
qtControl.CreateNewMovieFromImages( sourcePath,
                                    30,     // frame rate
                                    true ); // rate is in frames per seconds
var qtMovie = qtControl.Movie;
qtExporter.SetDataSource( qtMovie );

if ( CodecFileInfo )    {
    var xmlCodecInfoText = CodecFileInfo.ReadAll();
    // cause the exporter to be reconfigured
    // http://developer.apple.com/technotes/tn2006/tn2120.html
    var tempSettings = qtExporter.Settings;
    tempSettings.XML = xmlCodecInfoText;
    qtExporter.Settings = tempSettings;
} else  {
    qtExporter.ShowSettingsDialog();

    var xmlCodecInfoText = qtExporter.Settings.XML;
    CodecFileInfo = FileSystemObject.CreateTextFile( CodecInfoFileName );
    if ( CodecFileInfo )  {
        CodecFileInfo.WriteLine(xmlCodecInfoText);
        CodecFileInfo.Close();
    }
}
// do the actual export
qtExporter.DestinationFileName = destPath;
qtExporter.ShowProgressDialog = true;
qtExporter.BeginExport();
qtPlayerSrc.Close();

I have written a codec which allows QuickTime to read .pic files.

A few people have manually associated .pic files with the XSI flipbook or another viewer, but most people have them associated with the QuickTime Picture Viewer by default.

Installing this will not change your current file associations, but will allow the Picture Viewer to view .pic files when you double-click them instead of being greeted with an ”Unknown Format” error, caused by QuickTime thinking these are Apple PICT file.
It’s not necessary to have Softimage installed on the machine, this is completely self-contained

Content of the Package

• SoftimagePic.qtr
• SoftimagePic.qtx
• QuicktimeTestPic.pic
• Install.bat

Double-click Install.bat, which will copy the three other files to %ProgramFiles%\QuickTime\QTComponent, and will launch the Picture Viewer on QuicktimeTestPic.pic to verify the installation.
On Windows Vista and up with UAC, don’t forget to use Run As Administrator for the batch file, otherwise it won’t be able to copy the files.

I am not aware of any installation problem, but if somehow QuickTime isn’t finding the codec try to log out and back on to restart it.

Batch file hackers might be interested in seeing how I got the batch file to work from UNC drives, which isn’t supported by cmd.exe, or testing if the command prompt is 32-bit or 64-bit.

SoftimagePicCodecWIN1_2.zip (69k)

Preliminary OS X Version

Here is a Universal Binary port of this codec for OS X 10.4 (Tiger).

It will allow the QuickTime Player and other QuickTime-enabled apps to load Softimage .pic files. Unfortunately, this will not work in Preview or Finder previews as they by-pass QuickTime for .pic files and use an undocumented Core Image image mechanism instead. It is best to re-associate .pic files with the QuickTime player instead of Preview to allow easy double-click viewing of images. Please read the instructions contained in the installer.

The file contains a disk image with an installer which simply copies the component to /Library/QuickTime. A restart of the system is necessary at this time for the component to be detected.

SoftimagePicOSX.zip (128k)