Finding For The Light

2012-01-12T22:37:00.000-08:00

I started to develop of a GPU "Light Server" for renderman.
And for best understanding and debuging alghoritms I implemented a special Maya locator.
It generates random directions(vectors) in a hemisphere domain.
Color of the vectors calculate by light integrator of area light samples.

Compiling Alembic for Maya2012 under OpenSuse 11.2

2011-10-11T09:29:00.000-07:00

I done compiling the Alembic_1.0_2011080800 rev. with some changes in system.

!!! Warning. After installing working version of hdf5 was rewriting some libs like libz.a. Any programms call this lib may be finished with errors. I think it is a good reason for backup.
It is does impossible load Houdini “hou” module in Maya python or Idle editor. I could repair this functionality and finally I will write how-to.
1. So, in first we are doing changes in system:
1.1. Install make2.8
1.2. Install boost_1_42_0 from /usr/src/packages/SOURCES/
1.3. Install hdfs5. This one from official repositories does not work. I try dozen of hdf5 revisions but only hdf5-1.8.5-linux-x86_64-static-fpic I found passed for compiling Alembic. It available on http://www.hdfgroup.org/ftp/HDF5/prev-releases/hdf5-1.8.5/bin/linux-x86_64/hdf5-1.8.5-linux-x86_64-static-fpic.tar.gz. Unzip and install. One note about this package - that is, contain the critical libz.a.
1.4. Please check OpenExr libs. Usually ilmbase include in official Suse reositories.

2. Prepare Alembic instalation.
2.1. In ./Alembic_1.0_2011080800/build/AlembicMaya.cmake please add string
SET( MAYA_ROOT "/usr/autodesk/maya2010-x64" ).
2.2. In directory ./Alembic_1.0_2011080800/build/bootstrap run “alembic_bootstrap.py” configurator. I was agree with default path for alembic build dir - “alembic_build”. After I was enter requested path for to configure build. It is was:
/usr/include/boost/lexical_cast.hpp
/usr/local/lib/libboost_thread.a
/usr/include/zlib.h
/usr/lib64/libz.a
/usr/include/hdf5.h
/usr/lib64/libhdf5.a
/usr/include/OpenEXR/ImathMath.h
/usr/autodesk/maya2012-x64/lib/libImath.a

3. Installation.
3.1 In “alembic_build” dir write “make” and enter. I hope your installation will be successful.
3.2. After that you can find compiled plugins in .../alembic_build/maya/AbcExport and ./alembic_build/maya/AbcImport dirs.
Good luck!

renderman: displacment with overlapping in progress

2011-10-02T14:27:00.000-07:00

Actually I develop displacement shader with overlapping the top and bottom surface parts.

I have long had the idea to make displacement more expressive.

The implementation has been done with simple box kernel. This gave the artifacts to the overlapping parts

but I hope that the gaussian kernel will manage with it.

renderman: skin shader development in progress 2

2011-09-12T21:39:00.000-07:00

There is no life in it without any reflections

renderman: skin shader development in progress

2011-09-11T23:10:00.000-07:00

This is first step of development. It would measure dipole radius for this scene because I think "unitlength" may be wrong.

renderman: SH-Shadowing

2011-09-06T15:02:00.000-07:00

Old tools review : Light Zeppelin - BakeNaut Control Panel

2011-08-31T14:12:00.000-07:00

An example of an artist-friendly tools.
I really cannot understand why after 02 I wrote 06.

Old tools review : Light Zeppelin AE Templetes

2011-08-31T14:03:00.000-07:00

This is AE Templetes with dummy banners. Really bad color scheme.

Old tools review : Render Control

2011-08-30T13:12:00.000-07:00

This is UI and pipeline scripts was writen for "Frogs Paradise" 3D animation feature.

The Desert Drought Ground Shader

2011-08-28T07:03:00.000-07:00

This is procedural renderman contained displacement and surface methods. Main pattern was formed by Voronoy algorithm. Surface method is very simple - it have the minor mutation of colors and fake shadowing in cracks.

2011-08-28T06:38:00.000-07:00

Several month ago I wrote simple MAYA plug-in for converting data from MAYA PaintFX to renderman poinclouds. Generated pointclouds lightweight in contrast to ordinary baked ptc. In result point based occlusion don't physically corrected but plausible for long shots and very fast in rendering.

Production Video Editor

2011-08-27T08:40:00.001-07:00

This is the special tool for manage production, vewing and simple editing of sequences.
It is part of the total animation production management system "Atmosphere" that I develop with Andrew Chernysh . It's coded on PyQT. Work in progress.

Tricks with standart input/output and the renderman shader compiler

2011-08-23T14:29:00.000-07:00

Did you know that renderman shader compiler support the standart unix pipe?
I am looking for a way to rapidly develop co-shaders containing helpers data.
And I found a way that suits me.

in bash command line:

echo 'class test(float kd=0.7; float ks=0.1; color diffuse = color(1,0,0)){}' | shader -o /myProj/myShader.slo

echo 'class test(){ struct _data {varying float kd=0.7; varying float ks=0.1; varying color diffuse = color(1,0,0);}}' | shader -o /myProj/myShader.slo

in Maya mel:

system("echo 'class test(float kd=0.7; float ks=0.1; color diffuse = color(1,0,0)){}' | shader -o /myProj/myShader.slo");

or:

string $HelperContent = "'class test(float kd=0.7; float ks=0.1; color diffuse = color(1,0,0)){}'";
string $ShaderObject = "/myProj/myShader.slo";

system("echo "+$HelperContent+"|shader -o "+$ShaderObject);

in Maya python:

import os
os.system("echo 'class test(float kd=0.7; float ks=0.1; color diffuse = color(1,0,0)){}' | shader -o /myProj/myShader.slo")

Renderman rerendering - Camera Edits

2011-07-27T16:17:00.000-07:00

Actually I continue my connector maya to renderman rerendering. Work in progress.

PlayBlaster

2011-06-20T21:51:00.000-07:00

This video illustrate the "PlayBlaster" script for the production of animation playblasts with labels by one button-click. The Playblaster was writed for production pipeline of "Frogs Paradise" feature animation film. Animation by Marat Davletshin
PlayBlaster Tool from Alex Mirgorodsky on Vimeo.

Step By Step Pixar Style Eyes Shader. Step3: The Specular Components

2011-05-29T16:00:00.000-07:00

This is the last component needed for our shader eyes - specular glare and reflections.

ReflectivityComponents_SpecAndSpecRefl from Alex Mirgorodsky on Vimeo.

// cEyeShader.sl written by Alex Mirgorodsky 

// any questions about this shader code send on my e-mail: amir543@gmail.com
// This code free to copy and distribute. 

class cEyeShader(
    uniform float EyeIrisXPosition = 0.5;
    uniform float EyeIrisYPosition = 0.5;
    uniform color EyeIrisInColor = (0.322, 0.18, 0.0);
    uniform color EyeIrisMidColor = (0.541, 0.278, 0.063);
    uniform color EyeIrisOutColor = (0.322, 0.18, 0.0);
    uniform float EyePupilRadius = 0.03;
    uniform float EyeIrisRadius = 0.06;
    uniform float EyeIrisSeed = 1;
    uniform float EyeIrisCircularNoiseLevel = 0.2;
    uniform float EyeIrisRadialNoiseLevel = 0.75;
    uniform float EyeIrisRadialShift = 0.3;
    float EyeIrisMinLevel = 0.05;
    float EyeIrisCausticLevel = 3;
    float EyeKd = 0.7; // Koeffs Diffuse
    float EyeWa = 0.1; // Wideness Light Angle
    color ScleraHighlight = color(0.835, 0.9, 0.965);
    color ScleraLowlight = color(0.234, 0.234, 0.276);
    color ScleraCenterColorize = color(1);
    color ScleraOutColorize = color(1);
    float OffsetCircularColor = 3;
    float EyeShadowLevel = 0.1;
    string Category = "eye";
    // Specular 
    float EyeKs = 1;
    float SpecularRoughness = 0.003;
    float SpecularSharpness = 0.9;
    // Reflection
    float Refectivity = 1.0;
    float MaxDistance = 256;
    uniform float ReflSamples = 3;
   
    )
{
   
uniform float pi2 = 6.283185307;
shader lights[] ={};
shader categoryLights[] = {};
shader notCategoryLights[] = {};
constant float countLights = 0;
constant float countCategoryLights = 0;
constant float countNotCategoryLights = 0;

float linstep(float min, max, x)
    {
    float f;
    if (x < min) f = 0;
    if (x >= max) f = 1;
    f = (x-min)/(max-min);
    return f;
    }

float IrisNoise()
    {
    float angle;
    uniform float noiseScale1 = 100;
    uniform float noiseScale2 = 500;
   
    float d = distance(point(EyeIrisXPosition, EyeIrisXPosition, 0), point(s, t, 0));
        if (d != 0)     angle = asin((EyeIrisYPosition-t)/d);
        else   angle = 0;
        if (EyeIrisXPosition-s < 0) angle = PI - angle;
   
    float n1 = noise(s*noiseScale1, t*noiseScale1) * clamp(noise(s*noiseScale2, t
                *noiseScale2),.5, 1) * 2;
    float n2 = noise(angle*5+EyeIrisSeed);
       
    n1 = (n1 * EyeIrisCircularNoiseLevel) + (1-EyeIrisCircularNoiseLevel);
    n2 = (n2 * EyeIrisRadialNoiseLevel) + (1-EyeIrisRadialNoiseLevel);
   
    return n1*n2;
    }

normal NormalSurf()
{
    normal Ns ;
    normal Nn = normalize(N);
    uniform float depth;
               
    rayinfo("depth", depth);
        if(depth > 0) Ns = faceforward(Nn, normalize(I), Nn);
        else
        {
            uniform float sides = 2;
            attribute("Sides", sides);
            if(sides == 2)    Ns = faceforward(Nn, normalize(I), Nn);
            else Ns = Nn;
        }
               
    return Ns;
}   

float angularDistribution(float rotationAngle)
{
    float angleRad = radians(rotationAngle);
    float Sn = s-EyeIrisXPosition;
    float Tn = t - EyeIrisYPosition;
    float S_Rot = (Sn* cos(angleRad) - Tn*sin(angleRad)) + EyeIrisXPosition;
    float T_Rot = (Tn* cos(angleRad) + Sn*sin(angleRad)) + EyeIrisYPosition;
    float ss = (atan(T_Rot-EyeIrisYPosition, S_Rot-EyeIrisXPosition) + PI) / pi2;
    float outputDistribution = float spline ("bspline", ss, 1, 1, 0.5, 0, 0.5, 1, 1);
    return outputDistribution;
   
}
public void construct()
{
    lights = getlights();
    countLights = arraylength(lights);
   
    uniform string __category;
    uniform float i;
    for (i = 0; i < countLights; i += 1)
    {
        getvar(lights[i], "__category", __category);
        if(__category == Category) {
            push(categoryLights, lights[i]);
        } else {
            push(notCategoryLights, lights[i]);
        }
       
    }
    countCategoryLights = arraylength(categoryLights);
    countNotCategoryLights = arraylength(notCategoryLights);

}

public void surface(output color Ci, Oi)
    {
   
    // Dummy Difuse Color
    color Diffuse = color(1);
    // Pupil color (You can make your self solution for Pupil Lighting. But I use siple black color.
    color PupilColor = color(0);  
   
    float RadialDistribution = sqrt(pow((s-EyeIrisXPosition), 2) + pow((t-EyeIrisYPosition),2));
       
    float reDistribution = RadialDistribution / (EyeIrisRadius-EyePupilRadius);
    float kKorrection  = EyePupilRadius / (EyeIrisRadius-EyePupilRadius);
   
    float kSpline = float spline( "linear", reDistribution, kKorrection,
                    kKorrection, (EyeIrisRadialShift + kKorrection),
                    (1 + kKorrection), (1 + kKorrection));
    color IrisPainting = color spline( "linear", kSpline, EyeIrisInColor,
                    EyeIrisInColor, EyeIrisMidColor, EyeIrisOutColor, EyeIrisOutColor);
    IrisPainting = IrisPainting * IrisNoise(); // Add Noise to Iris
   
    color IrisColor_W_Pupil = mix(PupilColor, IrisPainting ,
                    clamp(linstep( EyePupilRadius, (EyePupilRadius +(EyePupilRadius/100)),
                    RadialDistribution),0,1));
   
   
    //------ Calculate Fake Tangent Map -------------------------------------------------------      
           
    float tangent = angularDistribution(180);
    float binormal = angularDistribution(90);
    color tangentAngularMap = color(tangent, binormal, 0.5);
       
    normal Ns = NormalSurf();
   
    normal Tangent = normal(tangentAngularMap);
    normal ReTangent =  2*Tangent - normal(1,1,1);
    //ReTangent = normal(ReTangent[0], ReTangent[1], ReTangent[2]);
    ReTangent = transform("object", "current", ReTangent);
    normal Unit = normal(0,0,1);
    normal ReNormal = normalize(Ns +(Unit - ReTangent));
                 
    //------ Lighting ----------------------------------------------------------------------------------     
    color fakeCaustic=0;
    float nondiff = 1;
    float InputAngle = -EyeWa*2;
    color diffColor = 0;
    //_lightingstart();
    uniform float i;
    for (i = 0; i < countCategoryLights; i += 1)
    {
        vector L;
        color Cl =0;
        float LightAngle;
        categoryLights[i]->light(L, Cl);
        //------Fake  Caustic  Computing ------------------------------------------------------
        float ratio = ReNormal.normalize(-L);
        fakeCaustic += pow((1+ratio)/2, 2);
        //------ Diffuse Computing With WDA-------------------------------------------------
       
        LightAngle  = normalize(-L).Ns;
        if(Ns.I > 0) LightAngle = -LightAngle;               
        LightAngle = clamp(LightAngle,InputAngle,1);
        LightAngle = (LightAngle - InputAngle) / (1 - InputAngle);
        getvar(categoryLights[i], "__nondiffuse", nondiff);
        if (nondiff <1)
            {
                diffColor += (1-nondiff) * Cl * LightAngle;
            }
    }
   
    //------- Shadows computing ----------------------------------------------------------------
    color inshadow=0;
    color accumShadow = 0;
    float accumRatio = 0;
   
    for (i = 0; i < countLights; i += 1)
    {
        vector L;
        color Cl =0;
        lights[i]->light(L, Cl);
           
        if( 0 != getvar(lights[i], "_shadow", inshadow))
            {
                accumShadow += inshadow;
            }
    }
   
    //accumRatio = accumRatio/countLights;
   
    color shadowHSL = ctransform("hsl", accumShadow);
    float shadowCalc = 1 - shadowHSL[2]*EyeShadowLevel;

    //------- Fake Caustic  --------------------------------------------------------------------------
   
    float pupilMask =  clamp(smoothstep( EyePupilRadius,
                    (EyePupilRadius +(EyePupilRadius/2)),RadialDistribution),0,1);
    float irisMask =  clamp(smoothstep((EyeIrisRadius
                    - (EyePupilRadius/2)), EyeIrisRadius, RadialDistribution),0,1);
    float pupilIrisMask = (1-irisMask)* pupilMask;
    float causticComp =  clamp((EyeIrisMinLevel
                + EyeIrisCausticLevel*pow(fakeCaustic[0], 2)*pupilIrisMask), 0,1);

   
    //------- Assemble Diffuse Components ---------------------------------------------------
    color diffuseHSL = ctransform("hsv", (diffColor*shadowCalc));
    color scleraColorRemap = mix(ScleraLowlight, ScleraHighlight, pow(diffuseHSL[2], 3));
   
    float Sn = s-EyeIrisXPosition;
    float Tn = t - EyeIrisYPosition;
    Sn = 1 - sqrt(2 * (Sn * Sn + Tn * Tn));
    color CircularColor = mix(ScleraOutColorize, ScleraCenterColorize,  pow(Sn,(1+OffsetCircularColor)));
   
    color IrisColor_W_Diffuse = mix(IrisColor_W_Pupil*causticComp, scleraColorRemap*CircularColor, 
                    filterstep(EyeIrisRadius, RadialDistribution));
   
                   
    //------ Reflective Components -------------------------------------------------------------
    float fkr, fkt;
    vector Refl, Refr;
    vector In = normalize(I);
    fresnel(In, Ns, 1.75187, fkr,fkt, Refl, Refr);
    //-------------------- Specular ------------------------------------------------------------------
    vector V = -normalize(I);
    color spec_color = 0;
    float glossyRegion  = SpecularSharpness/2;
    float nonspec = 0;
    color specular = 0;
    //vector Refl = reflect(normalize(I), normalize(N));
    color specOut = 0;
   
    for (i = 0; i < countCategoryLights; i += 1)
    {
        vector L;
        color Cl;
        categoryLights[i]->light(L, Cl);
   
        float nonspec = 0;
        getvar(categoryLights[i], "__nonspecular", nonspec); // getting specular weight koef from light 
       
        vector H = normalize(normalize(-L)+V); // Halfway vector 
       
        specular = Cl*(1-nonspec);
        spec_color += specular * (smoothstep (glossyRegion ,1-glossyRegion , pow(max(0,Ns.H), 1/SpecularRoughness)));
    }
    //---------------------- Environment Reflection --------------------------------------------
    vector ReflDir = reflect(normalize(I), Ns);
    color specularIndirect = 0;
   
    /* The pseudo Fresnel term - like Schlick Aproximation */
    float FrenelTerm = 1 - pow(normalize(-I).Ns, 0.6);
       
    color reflAccumulation = 0;
    color reflColor = 0;
   
    /* Reflection map.
    I use renderman user option string usually 
    for sent to a the scene shaders. 
    But for example I use simle string */
    string envMap = "street.env";
   
    gather("illuminance", P, ReflDir, 0,  ReflSamples,
            "distribution", "cosine",
            "maxdist", MaxDistance,
            "volume:Ci", reflColor)
            {
                reflAccumulation += reflColor;
            } else {
                ReflDir = transform ("ReflEnvMapCoordsys", ReflDir);
                reflAccumulation += environment(envMap, ReflDir, "width", 1 );
            }
    specularIndirect = (reflAccumulation / ReflSamples) * FrenelTerm * Refectivity;
   
    //------ Assemble All Components ---------------------------------------------------------
    color outcolor = IrisColor_W_Diffuse+spec_color+specularIndirect;
   
    Oi = color(1);
    Ci=outcolor;

    }

}

The next final step will be a small tuning to a custom specular shapes - a rectangle and ellipse.
Coming soon

Renderman RSL DSO Plugin for quering progress rendering

2011-03-13T12:21:00.000-07:00

I tested the new RenderMan Interface Control lib for the getting progress rendering
in shader calculating environment. The new Ric API include function RtInt RicGetProgress()
for returns percentage progress of rendering.
I wrote the little DSO with float function returns progress during rendering:

// progress.cpp source code
#include <stdio.h>
#include "RslPlugin.h"
#include "Ric.h"
extern "C" {
    RSLEXPORT int
    progressFloat(RslContext* rslContext,    int argc, const RslArg* argv[])
    {
        RslFloatIter result(argv[0]);
        *result = (float)(RicGetProgress());
        //printf("GetProgress --- %f\n", *result);
        return 0;
    }

    static RslFunction myFunctions[] =
    {
        {"varying float progress()", progressFloat, NULL, NULL },
        NULL
    };
RSLEXPORT RslFunctionTable RslPublicFunctions(myFunctions);
}; /* extern “C” */

And I used it in shader code for red-blue indexing of progress:

plugin  "progress";
.......
float pr = progress()*0.01; // 
Ci = mix(color(1,0,0), color(0,0,1), pr);

Main goal this function - calling for progress during re-rendering for optimizing calculation budget etc. But rerendring cals this function yielded unexpected results.

In next step I plan testing this one with a more complicated calculations.

If Maya Python doesn't find your package

2011-03-12T13:27:00.000-08:00

I am often faced with the problem - maya dont finded pakage modules
even path to the module present in PYTHONPATH environment variable.
And in feedback return something like this:

import  LightZeppelin
# Error: ImportError: line 1 of <maya console>: No module named LightZeppelin #

Early I solved this problem with

import sys
sys.path.append('myPath to package')

This is just work. But there is one more solution for this problem:

create your own *.pth file in $MAYA_LOCATION/lib/python2.6/site-packages directory

In my case - this is LightZeppelin.pth file contained one string - full path to DIRECTORY conteined "LightZeppelin" package.

This is very important. For example, if your pakage placed by /my_toolkit/my_subfolder/my_package

then in *.pth Your must write:

/my_toolkit/my_subfolder/

And after this one maya python finded your "my_package" by

import my_package

2011-03-12T01:40:00.000-08:00

HotOcean for MAYA 2010 Linux GCC 4.1

2011-02-04T15:05:00.000-08:00

hotOcean_Maya2010_LinuxGCC4.1.zip

I recompile HotOcean For MAYA 2010 GCC 4.1

For using it needs installed the fftw3 libs. In OpenSuse 11.2 fftw3 coming with standart repository.

some errors in the shader code

2011-01-12T02:50:00.000-08:00

I made some errors in the shader code
Firstly - I think it's better:

shader lights[] = getlights("category",Category);

than:

getvar(lights[i], "__category", __category);

        if(__category == Category) {
            push(categoryLights, lights[i]);
...............................

Secondly - to call the shaders in construt () method

- generally a bad idea if we want to use pixar relighting technology.

I think normally calling light co-shaders in lighting() method.

Step By Step Pixar Style Eyes Shader. Step2: Diffuse Lighting

2011-01-04T03:52:00.000-08:00

Hi All! Marry Christmas and Happy New Year!!!!
Last three month I've been really busy and tightened with the publication of the second part. So now I wrote it. In a first gone the Illustrations and all shaders code and in a second a minor clarifications to certain parts of code.

Eye Shader Illustrations 1 from Alex Mirgorodsky on Vimeo.
The code:

class cEyeShader(
    uniform float EyeIrisXPosition = 0.5;
    uniform float EyeIrisYPosition = 0.5;
    uniform color EyeIrisInColor = (0.025, 0.05, 0.01);
    uniform color EyeIrisMidColor = (0.7, 0.3, 0.02);
    uniform color EyeIrisOutColor = (0.025, 0.05, 0.01);
    uniform float EyePupilRadius = 0.03;
    uniform float EyeIrisRadius = 0.06;
    uniform float EyeIrisSeed = 1;
    uniform float EyeIrisCircularNoiseLevel = 0.2;
    uniform float EyeIrisRadialNoiseLevel = 0.75;
    uniform float EyeIrisRadialShift = 0.3;
    float EyeIrisMinLevel = 0.1;
    float EyeIrisCausticLevel = 3;
    float EyeKd = 1; // Koeffs Diffuse
    float EyeWa = 0.2; // Wideness Light Angle
    color ScleraHighlight = color(0.835, 0.9, 0.965);
    color ScleraLowlight = color(0.234, 0.234, 0.276);
    color ScleraCenterColorize = color(1);
    color ScleraOutColorize = color(1);
    float OffsetCircularColor = 3;
    float EyeShadowLevel = 0.0;
    string Category = "eye";
    )
{
    
uniform float pi2 = 6.283185307;
shader lights[] ={};
shader categoryLights[] = {};
shader notCategoryLights[] = {};
constant float countLights = 0;
constant float countCategoryLights = 0;
constant float countNotCategoryLights = 0;

float linstep(float min, max, x)
    {
    float f;
    if (x < min) f = 0;
    if (x >= max) f = 1;
    f = (x-min)/(max-min);
    return f;
    }

float IrisNoise()
    {
    float angle;
    uniform float noiseScale1 = 100;
    uniform float noiseScale2 = 500;
    
    float d = distance(point(EyeIrisXPosition, EyeIrisXPosition, 0), point(s, t, 0));
        if (d != 0)     angle = asin((EyeIrisYPosition-t)/d);
        else   angle = 0;
        if (EyeIrisXPosition-s < 0) angle = PI - angle;
    
    float n1 = noise(s*noiseScale1, t*noiseScale1) * clamp(noise(s*noiseScale2, t
                *noiseScale2),.5, 1) * 2;
    float n2 = noise(angle*5+EyeIrisSeed);
        
    n1 = (n1 * EyeIrisCircularNoiseLevel) + (1-EyeIrisCircularNoiseLevel);
    n2 = (n2 * EyeIrisRadialNoiseLevel) + (1-EyeIrisRadialNoiseLevel);
    
    return n1*n2;
    }

normal NormalSurf()
{
    normal Ns ;
    normal Nn = normalize(N);
    uniform float depth;
                
    rayinfo("depth", depth);
        if(depth > 0) Ns = faceforward(Nn, normalize(I), Nn);
        else
        {
            uniform float sides = 2;
            attribute("Sides", sides);
            if(sides == 2)    Ns = faceforward(Nn, normalize(I), Nn);
            else Ns = Nn;
        }
                
    return Ns;
}    

float angularDistribution(float rotationAngle)
{
    float angleRad = radians(rotationAngle);
    float Sn = s-EyeIrisXPosition;
    float Tn = t - EyeIrisYPosition;
    float S_Rot = (Sn* cos(angleRad) - Tn*sin(angleRad)) + EyeIrisXPosition;
    float T_Rot = (Tn* cos(angleRad) + Sn*sin(angleRad)) + EyeIrisYPosition;
    float ss = (atan(T_Rot-EyeIrisYPosition, S_Rot-EyeIrisXPosition) + PI) / pi2;
    float outputDistribution = float spline ("bspline", ss, 1, 1, 0.5, 0, 0.5, 1, 1);
    return outputDistribution;
    
}
public void construct()
{
    lights = getlights();
    countLights = arraylength(lights);
    uniform string __category;
    uniform float i;
    for (i = 0; i < countLights; i += 1) 
    {
        getvar(lights[i], "__category", __category);
        if(__category == Category) {
            push(categoryLights, lights[i]);
        } else {
            push(notCategoryLights, lights[i]);
        }
    }
    countCategoryLights = arraylength(categoryLights);
    countNotCategoryLights = arraylength(notCategoryLights);

}

public void surface(output color Ci, Oi)
    {
    
    // Dummy Difuse Color
    color Diffuse = color(1);
    // Pupil color (You can make your self solution for Pupil Lighting. But I use siple black color.
    color PupilColor = color(0);   
    
    float RadialDistribution = sqrt(pow((s-EyeIrisXPosition), 2) + pow((t-EyeIrisYPosition),2));
        
    float reDistribution = RadialDistribution / (EyeIrisRadius-EyePupilRadius);
    float kKorrection  = EyePupilRadius / (EyeIrisRadius-EyePupilRadius);
    
    float kSpline = float spline( "linear", reDistribution, kKorrection, 
                    kKorrection, (EyeIrisRadialShift + kKorrection), 
                    (1 + kKorrection), (1 + kKorrection));
    color IrisPainting = color spline( "linear", kSpline, EyeIrisInColor, 
                    EyeIrisInColor, EyeIrisMidColor, EyeIrisOutColor, EyeIrisOutColor);
    IrisPainting = IrisPainting * IrisNoise(); // Add Noise to Iris
    
    color IrisColor_W_Pupil = mix(PupilColor, IrisPainting , 
                    clamp(linstep( EyePupilRadius, (EyePupilRadius +(EyePupilRadius/100)), 
                    RadialDistribution),0,1));
    
    //------ Calculate Fake Tangent Map -------------------------------------------------------      
            
    float tangent = angularDistribution(180);
    float binormal = angularDistribution(90);
    color tangentAngularMap = color(tangent, binormal, 0.5);
        
    normal Ns = NormalSurf();
    
    normal Tangent = normal(tangentAngularMap);
    normal ReTangent =  2*Tangent - normal(1,1,1);
    ReTangent = normal(ReTangent[0], ReTangent[1], ReTangent[2]);
    ReTangent = transform("object", "current", ReTangent);
    normal Unit = normal(0,0,1);
    normal ReNormal = normalize(Ns +(Unit - ReTangent));
                  
    //------ Lighting ----------------------------------------------------------------------------------     
    color fakeCaustic=0;
    float nondiff = 1;
    float InputAngle = -EyeWa*2;
    color diffColor = 0;
    
    uniform float i;
    for (i = 0; i < countCategoryLights; i += 1) 
    {
        vector L;
        color Cl =0;
        float LightAngle;
        categoryLights[i]->light(L, Cl);
        //------Fake  Caustic  Computing ------------------------------------------------------
        float ratio = ReNormal.normalize(-L);
        fakeCaustic += pow((1+ratio)/2, 2);
        //------ Diffuse Computing With WDA-------------------------------------------------
        
        LightAngle  = normalize(-L).Ns;
        if(Ns.I > 0) LightAngle = -LightAngle;                
        LightAngle = clamp(LightAngle,InputAngle,1);
        LightAngle = (LightAngle - InputAngle) / (1 - InputAngle);
        getvar(categoryLights[i], "__nondiffuse", nondiff);
        if (nondiff <1)
            {
                diffColor += (1-nondiff) * Cl * LightAngle;
            }
    }
    
    //------- Shadows computing ----------------------------------------------------------------
    color inshadow=0;
    color accumShadow = 0;
    //float accumRatio = 0;
    
    for (i = 0; i < countLights; i += 1) 
    {
        vector L;
        color Cl =0;
        lights[i]->light(L, Cl);
            
        if( 0 != getvar(lights[i], "_shadow", inshadow))
            {
                accumShadow += inshadow;
            }
    }
    color shadowHSL = ctransform("hsl", accumShadow);
    float shadowCalc = 1 - shadowHSL[2]*EyeShadowLevel;

    //------- Fake Caustic  --------------------------------------------------------------------------
    
    float pupilMask =  clamp(smoothstep( EyePupilRadius, 
                    (EyePupilRadius +(EyePupilRadius/2)),RadialDistribution),0,1);
    float irisMask =  clamp(smoothstep((EyeIrisRadius 
                    - (EyePupilRadius/2)), EyeIrisRadius, RadialDistribution),0,1);
    float pupilIrisMask = (1-irisMask)* pupilMask;
    float causticComp =  clamp((EyeIrisMinLevel 
                + EyeIrisCausticLevel*pow(fakeCaustic[0], 2)*pupilIrisMask), 0,1);
    
    //------- Assemble Diffuse Components ---------------------------------------------------
    color diffuseHSL = ctransform("hsv", (diffColor*shadowCalc));
    color scleraColorRemap = mix(ScleraLowlight, ScleraHighlight, pow(diffuseHSL[2], 3)); 
    
    float Sn = s-EyeIrisXPosition;
    float Tn = t - EyeIrisYPosition;
    Sn = 1 - sqrt(2 * (Sn * Sn + Tn * Tn));
    color CircularColor = mix(ScleraOutColorize, ScleraCenterColorize,  pow(Sn,(1+OffsetCircularColor)));
    
    color IrisColor_W_Diffuse = mix(IrisColor_W_Pupil*causticComp, scleraColorRemap*CircularColor,  
                    filterstep(EyeIrisRadius, RadialDistribution));
    
    //------ Assemble All Components ---------------------------------------------------------
    color outcolor = IrisColor_W_Diffuse;

    Oi = color(1);
    Ci=outcolor;
    }
}

I use synth of normal map for fake illumination of iris-pupil stria. Of course we could do it without any color implementations. But it easy for understanding of.

float tangent = angularDistribution(180);
float binormal = angularDistribution(90);
color tangentAngularMap = color(tangent, binormal, 0.5);

In a real eye( human eye) this is narrow groove. But in a cartoon animations we use exaggerations for most effects - and I make full Iris-size fake caustic highlight. In any case You may change the part of code for making "pupilIrisMask":

float pupilMask =  clamp(smoothstep( EyePupilRadius, 
                    (EyePupilRadius +(EyePupilRadius/2)),RadialDistribution),0,1);
float irisMask =  clamp(smoothstep((EyeIrisRadius 
                    - (EyePupilRadius/2)), EyeIrisRadius, RadialDistribution),0,1);
float pupilIrisMask = (1-irisMask)* pupilMask;

Diffuse Lighting of sclera I separate in two illumination loops. Lighting I make ONLY the special light with __category and a shadows I catching from all light in scene. And finnaly I make color remapping for the diffuse component of sclera by couples variables "ScleraHighlight-ScleraLowlight" and "ScleraCenterColorize-ScleraOutColorize"
In final third part - we will make reflection components for the Eye Shader.
next step 3
previous step 1

Lighting Works (From Old Projects)

2010-12-03T01:04:00.000-08:00

Lighting_work1(Old Projects) from Alex Mirgorodsky on Vimeo.

PS - First shot lighting work by Dmitry Fedotov

Step By Step Pixar Style Eyes Shader. Step1: Iris Texturing

2010-11-06T15:47:00.000-07:00

First of all, this solution was realised how ST projection.
I mean, position and of Eye Iris is depend from UV mapping only,
not from 3d projection. The image below demonstrate is UV-layout
of polygonal eye.

And second of all, model quality is such as it is - I am not modeller.
I use RSL2.0 style, but You can rewrite to old RSL style - code is simple. I devide this tutor on some few articles -
Iris Texturing, Diffuse shading, Fake caustic, Reflection components.
So is code below:

class cEyeShader(
    uniform float EyeIrisXPosition = 0.5;
    uniform float EyeIrisYPosition = 0.5;
    uniform color EyeIrisInColor = (0.025, 0.05, 0.01);
    uniform color EyeIrisMidColor = (0.7, 0.3, 0.02);
    uniform color EyeIrisOutColor = (0.025, 0.05, 0.01);
    uniform float EyePupilRadius = 0.04;
    uniform float EyeIrisRadius = 0.06;
    uniform float EyeIrisSeed = 1;
    uniform float EyeIrisCircularNoiseLevel = 0.2;
    uniform float EyeIrisRadialNoiseLevel = 0.75;
    uniform float EyeIrisRadialShift = 0.3;
    )
{

float linstep(float min, max, x)
    {
    float f;
    if (x < min) f = 0;
    if (x >= max) f = 1;
    f = (x-min)/(max-min);
    return f;
    }

float IrisNoise()
    {
    float angle;
    uniform float noiseScale1 = 100;
    uniform float noiseScale2 = 500;
    
    float d = distance(point(EyeIrisXPosition, EyeIrisXPosition, 0), point(s, t, 0));
        if (d != 0)     angle = asin((EyeIrisYPosition-t)/d);
        else   angle = 0;
        if (EyeIrisXPosition-s < 0) angle = PI - angle;
    
    float n1 = noise(s*noiseScale1, t*noiseScale1) * clamp(noise(s*noiseScale2, t
                *noiseScale2),.5, 1) * 2;
    float n2 = noise(angle*5+EyeIrisSeed);
        
    n1 = (n1 * EyeIrisCircularNoiseLevel) + (1-EyeIrisCircularNoiseLevel);
    n2 = (n2 * EyeIrisRadialNoiseLevel) + (1-EyeIrisRadialNoiseLevel);
    
    return n1*n2;
    }
    
public void surface(output color Ci, Oi)
    {
    
    // Dummy Difuse Color
    color Diffuse = color(1);
    // Pupil color (You can make your self solution for Pupil Lighting. But I use siple black color.
    color PupilColor = color(0);   
    
    float RadialDistribution = sqrt(pow((s-EyeIrisXPosition), 2) + pow((t-EyeIrisYPosition),2));
        
    float reDistribution = RadialDistribution / (EyeIrisRadius-EyePupilRadius);
    float kKorrection  = EyePupilRadius / (EyeIrisRadius-EyePupilRadius);
    
    float kSpline = float spline( "solvecatrom", reDistribution, kKorrection, 
                    kKorrection, (EyeIrisRadialShift + kKorrection), 
                    (1 + kKorrection), (1 + kKorrection));
    color IrisPainting = color spline( "catrom", kSpline, EyeIrisInColor, 
                    EyeIrisInColor, EyeIrisMidColor, EyeIrisOutColor, EyeIrisOutColor);
    
    IrisPainting = IrisPainting * IrisNoise(); // Add Noise to Iris
    
    color IrisColor_W_Pupil = mix(PupilColor, IrisPainting , 
                    clamp(linstep( EyePupilRadius, (EyePupilRadius +(EyePupilRadius/100)), 
                    RadialDistribution),0,1));
    color IrisColor_W_Diffuse = mix(IrisColor_W_Pupil, Diffuse,  
                    filterstep(EyeIrisRadius, RadialDistribution));
    
    color outcolor = IrisColor_W_Diffuse;
    Oi = color(1); 
    Ci = outcolor;
    }
}

In first we making circular ramp for RadialDistribution:

float RadialDistribution = sqrt(pow((s-EyeIrisXPosition), 2) + pow((t-EyeIrisYPosition),2));

float reDistribution = RadialDistribution / (EyeIrisRadius-EyePupilRadius);

Next step - bulding Circular ramp and multiply it on special Noise function. I brought in a separate float function IrisNoise(). It is a bit complicate with radial and circular components.
And this release function might potential problems in case radical uv-offseting of position center Iris.

float kSpline = float spline( "solvecatrom", reDistribution, kKorrection, 
                    kKorrection, (EyeIrisRadialShift + kKorrection), 
                    (1 + kKorrection), (1 + kKorrection));
    color IrisPainting = color spline( "catrom", kSpline, EyeIrisInColor, 
                    EyeIrisInColor, EyeIrisMidColor, EyeIrisOutColor, EyeIrisOutColor);
    IrisPainting = IrisPainting * IrisNoise(); // Add Noise to Iris

Now we add pupil component:

color IrisColor_W_Pupil = mix(PupilColor, IrisPainting , 
            clamp(linstep( EyePupilRadius, (EyePupilRadius +(EyePupilRadius/100)), 
            RadialDistribution),0,1));

And in final this article we cropped Iris by outside circle:

color IrisColor_W_Diffuse = mix(IrisColor_W_Pupil, Diffuse,  
        filterstep(EyeIrisRadius, RadialDistribution));

To be continued...
step 2
step 3

Little Shell Scripting

2010-10-20T09:56:00.000-07:00

1. Converting all .tif in directory to .tex files
name: convert_tif_tex.sh
content:

#!/bin/bash
for i in *.tif; do txmake -mode periodic -verbose "$i" "${i%.tif}.tex"; done

2. Downscaling geometry size all .tif files to 25% of original images. 
It making by "mogrify" utility - the part of ImageMagick pack.
name : mogrify_25prct_tif.sh
content:

#!/bin/bash
for i in *.tif; do mogrify -geometry 25% "$i" ; done

3. Converting .ui files from QTDesigner to PyQt .py 
name: ui2py.sh
content:

#!/bin/bash
name=`basename $1 .ui`
echo "------- $name ------"
pyuic4 ./$1 -o ./$name.py

Step By Step Pixar Style Eyes Shader. Comming Soon.

2010-10-20T00:52:00.000-07:00

Name Surface shader in Slim

2010-10-18T13:32:00.000-07:00

This is example code from my old "SLO_Inspector" utility.

1. Getting Id of Ensemble Object on geometryShape (pSphereShape1 as example):
string $Id[] = `getAttr pSphereShape1.slimEns`;
// Result: 2000_fsgyo400000 //

2 Getting handle of appearence ( the our Ensemble):
string $app_handle = `slimcmd slim GetAppearances -id $Id[0]`;
// Result: func1 //

2.1. Checking shading object name by handle:
string $Name_Shader = `slimcmd $app_handle GetName`;
// Result: Ens_1 // (yes - it name "Ens_1")

3. Getting handle a Surface Shader connected in "Surface" slot:
string $GetSurface_Handle = `slimcmd $app_handle GetProperties -type "surface"`;
// Result: parm26 //

3.1. We can check the right surface handle:
string $Name_Shader1 = `slimcmd $GetSurface_Handle GetName`;
// Result: Surface // - it's really "Surface" handle

4. Getting Id number of connected Surface shader:
string $Id_Surface_Shader = `slimcmd $GetSurface_Handle GetConnection`;
// Result: 2000_rEBbZ400000 //

5. Getting handle of Surface shader:
string $Surface = `slimcmd slim GetAppearances -id $Id_Surface_Shader`;
// Result: func0 //

6. Getting name of Surface Shader
string $NameSurface = `slimcmd $Surface GetName`;
// Result: Blinn //

Amazing video from "Crysis" development

2010-10-13T23:27:00.001-07:00

Crysis nearing Avatar quality from Oscar on Vimeo.

Some old scenes from "Frogs Paradise" Feature Animation Films (without compositing)

2010-08-27T13:29:00.000-07:00

from 20Sequence from DaVinci on Vimeo.

Animation (Some Scenes) from DaVinci on Vimeo.

Autodesk MAYA Bug Tracking page

2010-07-22T11:25:00.000-07:00

http://spreadsheets.google.com/ccc?key=pdI8BlSwGdr0btApDuZEcKQ&inv=py&pli=1#gid=0

V-Day in Moscow

2010-07-12T15:57:00.000-07:00

2010-07-05T16:05:00.000-07:00

Compiling the HotOcean deformer for the MAYA2008

2010-07-03T10:52:00.000-07:00

This is operation i use for compiling HotOcean plugin writed by Igor Žanić
source code of HotOcean located: http://sites.google.com/site/igorvfxsite/igorfx

OS - OpenSuse11.2
Maya2008
GCC4.1 compiler

So compiling:
g++-4.1 -c -I. -I.. -I/usr/autodesk/maya2008-x64/include -I/usr/include/OpenEXR -I/usr/X11R6/include -DBits64_ -m64 -DUNIX -D_BOOL -DLINUX -DFUNCPROTO -D_GNU_SOURCE -DLINUX_64 -fPIC -fno-strict-aliasing -DREQUIRE_IOSTREAM -Wno-deprecated -O3 -Wall -Wno-multichar -Wno-comment -Wno-sign-compare -funsigned-char -Wno-reorder -fno-gnu-keywords -ftemplate-depth-25 -pthread -Wno-deprecated -fno-gnu-keywords hotOcean.cpp

and linking:
g++-4.1 -DBits64_ -m64 -DUNIX -D_BOOL -DLINUX -DFUNCPROTO -D_GNU_SOURCE -DLINUX_64 -fPIC -fno-strict-aliasing -DREQUIRE_IOSTREAM -Wno-deprecated -O3 -Wall -Wno-multichar -Wno-comment -Wno-sign-compare -funsigned-char -Wno-reorder -fno-gnu-keywords -ftemplate-depth-25 -pthread -Wno-deprecated -fno-gnu-keywords -Wl,-Bsymbolic -shared -o hotOcean.so hotOcean.o -L/usr/lib64/ -lfftw3f -lm -lblitz -lImath -L/usr/autodesk/maya2008-x64/lib -lOpenMaya -lFoundation -lOpenMayaAnim

After loading hotOcean.so in Maya I use by Igor Žanić video.

HOT for Maya - ocean spray - basic tutorial from Igor Zanic on Vimeo.

Musion Box on AtomExpo2010

2010-06-29T14:30:00.000-07:00

Testing Musion Box in Rosatom Exposition. It is to be regretted that dust accumulated on musion film.

2010-06-28T15:24:00.001-07:00

Light My Fire

2010-06-27T15:55:00.000-07:00

Up In The Air

2010-06-27T15:42:00.000-07:00

Rosatom Logo Animation

2010-06-09T00:36:00.000-07:00

rosatom logo animation from DaVinci on Vimeo.

tickets to the moon

2010-05-12T01:10:00.000-07:00

Utility for assembling exrs cropped images after prman crop render. This tool like "tiffjoin" from prman toolkit, but my "exr_join" assembling multy-channel exrs generally rendered to secondary display.

Fading Of Dream

2010-04-27T00:23:00.000-07:00

I recently faced problem of converting huge pointclouds in brickmaps. So I wrote litle utility to decrease density points in ptc.

Certainly this is bad subdiv based on poligon with multivalent vertices. But it is good to show conversion to pointclouds.

10 x decreased poincloud:

100 x decreased pointcloud:

1000 x decreased pointcloud:

CoolIris

2010-03-31T13:35:00.000-07:00

I think among a galore firefox plugins, the CoolIris really shiny dimond :)
It power tool for finding images across primary search-engines. Modern design and usability do searching really fascinating.

Oh Suse

2010-03-11T15:02:00.000-08:00

I waiting a long time for the stable versions Suse11. And now I say - "Hello 11.2, but - Dont Goodbay 10.3"

Cylon Render

2010-02-12T03:53:00.000-08:00

"The Cylons were created by man, they rebelled, they evolved. They look and feel human. Some are programmed to think they are human. There are many copies and they have a plan."

Atmosphere

2010-02-12T03:31:00.000-08:00

Managment System developed last year by me and Andrew Chernysh

is rebranded!

2010-02-10T12:25:00.000-08:00

2010-02-05T22:57:00.000-08:00

Render pipeline prerealised. This is part of big animation pipeline.

New Episode

2010-01-22T07:53:00.000-08:00

Untitled from DaVinci on Vimeo.

UberLightHelper realised

2009-12-02T01:04:00.000-08:00

http://www.creativecrash.com/maya/downloads/scripts-plugins/rendering/renderman/c/uberlighthelper

"stupid modelling tricks"

2009-11-27T02:19:00.000-08:00

Sometime I keen regret for lack of Big Gun - when in Shading Department come up scenes like this!

MOON

2009-11-25T15:05:00.001-08:00

Perfect movie - by Duncan Jones and music by Clint Mansell
http://www.imdb.com/title/tt1182345/

Main Control Room In Frogs Space Ship

2009-11-25T06:19:00.000-08:00

Untitled from DaVinci on Vimeo.

Sometimes They Come Back...

2009-11-24T13:01:00.000-08:00

Frogs Paradise(work materials) from DaVinci on Vimeo.

Hello World !!!

2009-11-24T12:42:00.000-08:00

This is my first message!!!