Installation

Maya plugin

1) Unpack the .zip archive

2) Windows only: Install Visual Studio 2010 redistributable

3) Copy maya directory over your user maya directory

Windows 7	C:\Users\<your user account>\Documents\maya
english Windows XP	C:\Documents and Settings\<your user account>\My Documents\maya
german Windows XP	C:\Dokumente und Einstellungen\<your user account>\Eigene Dateien\maya
Mac OS X	/Users/Shared/Autodesk/maya

4) Open Maya or restart it

5) Load the plugin "Inka3D" in Maya via Window -> Settings/Preferences -> Plug-in Manager

First test

1) Set the project to the examples folder and open an example

2) Export using File -> Export All... (Maya 2010 and below: click on square)

3) Select File type: Inka3D HTML/WebGL Exporter

4) Select the following export options (File Type Specific Options)

Interface Nodes	None
List of Nodes	leave empty
Interface Transforms	unchecked
Interface Locators	unchecked
Interface Cameras	checked
Interface Lights	unchecked
Export Render Layers	unchecked
Add Pick Layer	unchecked
No Bump Mapping	unchecked
No Pixel Processing	unchecked

Note: a camera shape named “cameraShape1” must be present.

5) Export to the WebGL directory (contained in the .zip archive) as test.html

6) Start InkaServer inside WebGL directory (do it inside a console as double-clicking from explorer/finder starts it with some other directory as current directory)

7) Go to http://localhost/test.html or http://localhost:8080/test.html (see output of InkaServer)

8) If you change the .html file and your scene you can export the .js file using Inka3D JavaScript/WebGL Exporter so that your changes in the .html file don't get overwritten. Repeat step 4 to set the export options, export and then hit the reload button in your browser.

Troubleshooting

Maya plugin does not load: Install Visual Studio 2010 redistributable (32/64 bit depending on your Maya version).

When exporting maya says Cannot find procedure "Inka3DOptionsDirect": Restart Maya. If it does not help, Inka3DOptionsDirect.mel may be missing in maya/<version>/scripts directory. Repeat step 3 of installation and make sure to copy the whole maya directory, not only the plugin itself.

Install new graphics driver. Maybe yours is blacklisted by your browser.

Make sure you use a HTTP server (e.g. InkaServer) to view exported content as loading from file may not work.

Scene loading stops at progress bar: set "Interface Cameras" export option and make sure cameraShape1 is present in your scene.

Other strange behavior: In the header of the exported html file after

<script type="text/javascript" src="js/inka3d.js"></script>

add this line:

<script type="text/javascript" src="js/inka3dDebug.js"></script>

Then open a javascript debug console.

Rendering is slow or has low resolution: check current zoom factor of your browser. Should be 100%.

API

HTML Header

In the head section of your html include the following javascript files:

<script type="text/javascript" src="js/webgl-utils.js"></script>
<script type="text/javascript" src="js/inka3d.js"></script>

Also include your exported scene:

<script type="text/javascript" src="MyScene.js"></script>

If you use the Inka3D HTML/WebGL exporter then a simple HTML wrapper file is created for you.

Initialization

Renderer and render groups

In the script code, first create a renderer with given number of render jobs, e.g.

renderer = digi.createRenderer(100);

You need as many render jobs as you render shapes. If you use geometry instancing, i.e. render an object per particle, you need one render job for every particle. If the particle system has a maximum of 500 particles you should pass 600 here. If rendering starts flickering or you don't see all objects you probably have too few render jobs. The next thing to do is to create a render group

group = renderer.createGroup();

This is a collection of scenes you want to render at a time. At first one group should be enough, but you can do things like overlays with it. Render one group, clear the z-buffer and then render another group.

Start loading

Now initialize the exported scene (or collection of exported scenes - creating scene collections requires an extra tool that is available on request). Call init() on the scene

MyScene.init();

Now the scene starts loading asynchronously.

Observing load progress

The scene has an attribute called numLoaded which tells you how many resources (e.g. textures) are already loaded and an attribute called numResources that tells you how many resources there are to load. With this you can create a loading bar or other progress display. The code could look like this:

var progress = (MyScene.numLoaded + 0.5) / MyScene.numResources;
if (progress < 1)
{
	// continue waiting...
	requestAnimFrame(waitLoad);
	
	// display loading bar or percentage
	...
}
else
{
	// loading finished

	// init gl
	gl.clearColor(0, 0, 0, 1);
	gl.enable(gl.DEPTH_TEST);
	
	// create scenes
	...
}

Creating scenes

Now that the loading has finished we can create an instance of a scene in our render group:

scene = MyScene.createScene("MyScene", group);

It is possible to do this more than once in the same group or different groups.

Interfacing scenes

There are several methods to access the attributes of a scene. The names of the attributes are the same as in Maya. To find out the name of an attribute, simply modify it in Maya and look for the output in the script editor. Then copy-and-paste the name (e.g. "pcube1.translate") to your javascript editor. These methods can be used to access attributes:

getIntVector(name, length)	returns Int32Array if attribute has given length
getIntArray(name)	returns Int32Array for attribute
getFloatVector(name, length)	returns Float32Array if attribute has given length
getFloatArray(name)	returns Float32Array for attribute
getTexture(name)	returns WebGL texture object
getTexture(name, index)	returns WebGL texture object of texture sequence
setTexture(name)	sets WebGL texture object
setTexture(name, index)	sets WebGL texture object of texture sequence

The returned arrays of type Int32Array or Float32Array can be stored and then used to read and write attributes very fast. Attributes of scalar type are accessed with typed arrays of length 1.

Now we can extract the global animation time attribute from the scene:

sceneTime = scene.getFloatVector("time", 1);

We can use a Maya camera for rendering by finding its world matrix and projection attributes:

sceneCameraMatrix = scene.getFloatVector("cameraShape1.worldMatrix[0]", 16);
sceneProjection = scene.getFloatArray("cameraShape1.projection");

Search for "parameterInfos:" in the exported .js file to see which attributes are available. If the attribute you are looking for is missing, check the export options while exporting from Maya.

Setting attributes

You can set scalar or vector attributes by simply assigning a value using the array operator ([...]). For example for the sceneTime this could be

sceneTime[0] = new Date().getTime() / 1000.0 - startTime;

Getting attributes

You can query the current state of attributes. Scalar or vector attributes are read by using the array operator ([...]). For example you can get the current scene time by

var currentTime = sceneTime[0];

To use a camera that is in your Maya scene for rendering, you use the current state of sceneCameraMatrix and sceneProjection by

digi.matrix4x4Inv(sceneCameraMatrix, viewMatrix);
digi.matrix4x4Projection(sceneProjection, aspect, projectionMatrix);

Where viewMatrix and projectionMatrix are a Float32Array of length 16 that can be allocated once in the initialization code.

Main loop

It is your responsibility to create a main loop. This way you can set a render target and apply postprocessing as you like. A typical main loop looks like this: set attributes, update, calculate viewMatrix and projectionMatrix, clear screen, render.

Update

After you have set all attributes, update the scenes by using

group.update();

This recalculates all world transformations, all animations and all other dependent attributes.

Rendering

Rendering is done on a render group. A view matrix, a projection matrix and a render layer name are passed to the render function:

group.render(viewMatrix, projectionMatrix, renderLayer);

The renderLayer parameter selects a render layer of your Maya scene. Use "color" if you don't use render layers.

Picking

To find out which object is under the mouse curser you can use getObjectId(name) on a scene in the init function to get an id for an object. Use the name of a shape in your scene with the instance index in square brackets, e.g.

var cubeId = scene.getObjectId("pCubeShape1[0]");

Then, in the main loop, use the pick function on a render group. You also have to pass a view and projection matrix which can be the same as for rendering. Also pass the mouse coordinates in device space, i.e. ranging from -1 to 1 over your viewport. The (-1, -1) point is the lower left corner, (0, 0) is the center.

var id = group.pick(viewMatrix, projectionMatrix, mouseX, mouseY);

Now if id equals cubeId the cube was picked.

Export options

Interface Nodes

This option tells the exporter which nodes are visible in the interface and therefore if their attributes can be modified by Javascript. You can select all, a list of nodes or none. The list of nodes is a list of comma (',') or semicolon (';') separated list of node names. For example if you want to interface to the attributes of a cube and a sphere, the list could be "pCube1,pSphere1". It is beneficial to interface to as few nodes as possible as this increases performance and reduces file size. You can bring together all attributes of a scene that you want to control by adding extra attributes to one node and connect these to the attributes in the scene. Hint: Search for "parameterInfos:" in the exported .js file to see which attributes are in the interface. Try to keep the list short if you want to optimize.

Interface Transforms

All attributes of all transform nodes are visible in the interface in addition to the other settings. Some scenes contain thousands of transform nodes which will result in very long export times when this option is on.

Interface Locators

All attributes of all locators are visible in the interface in addition to the other settings.

Interface Cameras

All attributes of all camera nodes are visible in the interface in addition to the other settings. Cameras have the special attribute projection (e.g. "cameraShape1.projection") that contains the camera projection attributes such as Focal Length, Near/Far Clip Plane, Camera Aperture, Film Aspect Ratio, Fit Resolution Gate and Orthographic. From this a projection matrix can be calculated using the screen aspect ratio.

Interface Lights

All attributes of all light nodes are visible in the interface in addition to other settings.

Export Render Layers

Maya's render layers get exported. With this you can selectively render indivitual parts of the scene as the render function takes a render layer name. By default the layer named "color" is rendered. If you create a layer named "color" you can control which objects are rendered. Also the picking can be controlled using a render layer named "pick". All objects that are in the pick layer are pickable. With this you can define an invisible plane for picking or exclude objects from picking.

Add Pick Layer

A pick layer is generated in the output code even if no pick layer is defined in the scene. If Export Render Layers is on and a layer named "pick" exists then all objects in this layer are pickable. Ohterwise all objects are pickable.

No Bump Mapping

Omit bump mapping of all shaders. Useful for low-end targets such as tablets.

No Pixel Processing

Simplifies the pixel shaders by doing most calculations in the vertex shader. Quality degrades more or less dependent on shader. For example ramp textures are evaluated per vertex. Useful for low-end targets such as tablets.

Supported Maya Features

Scene

AnimCurve

Standard animation curve, created when using „Set Key“. All tangent types are supported except Stepped Next.

Expression

All C-Like constructs supported. Example:

if (pCube1.rotateX > 30.0)
{
	pCube1.translateX = sin(0.5 * time);
}
else
{
	pCube1.translateX = pCube1.translateZ;
}

Object types and lists are not supported.

Limit functions:

abs(x)	Absolute value: abs(-1) → 1
ceil(x)	Round up: ceil(0.1) → 1
floor(x)	Round down: floor(0.9) → 0
clamp(min, max, x)	Clamp
min(x, y)	Minimum
max(x, y)	Maximum
sign(x)	Sign: -1, 0 or 1
trunc(x)	Truncate: trunc(1.5) → 1, trunc(-1.5) → -1

Exponential functions:

exp(x)	e^x
log(x)	Logarithm base e
log10(x)	Logarithm base 10
pow(x, y)	x^y
sqrt(x)	Square root

Trigonometric functions:

cos(x)	Cosine
cosd(x)	Cosine taking degrees
sin(x)	Sine
sind(x)	Sine taking degrees
tan(x)	Tangent (sin(x)/cos(x))
tand(x)	Tangent taking degrees
atan2(y, x)	Arc tangent
atan2d(y, x)	Arc tangent returning degrees
hypot(x, y)	Length of 2D vector (x, y)

Vector functions:

angle(x, y)	Angle between two vectors
cross(x, y)	Cross product
dot(x, y)	Dot product
mag(x)	Length of vector
unit(x)	Normalized vector, unit length

Random functions:

gauss(stdDev)	1D or 3D random numbers with Gaussian distribution
gauss(stdDevX, stdDevY)	2D random numbers with Gaussian distribution
noise(x)	1D or Perlin scalar noise
noise(x, y)	2D Perlin scalar noise
noise(vector)	3D Perlin scalar noise
dnoise(vector)	3D Perlin vector noise
rand(maxValue)	1D or 3D random numbers in the range 0 to maxValue
rand(minValue, maxValue)	1D or 3D random numbers in the range minValue to maxValue
sphrand(radius)	3D random numbers inside a sphere or ellipsoid

Curve functions:

linstep(start, end, parameter)	Linear step from 0 to 1
smoothstep(start, end, parameter)	Smooth step from 0 to 1
hermite(p1, p2, tan1, tan2, alpha)	Hermite spline with tangents tan1 and tan2

Camera

Defines view and projection matrix.

focalLength	Animatable
nearClipPlane	Animatable
farClipPlane	Animatable
cameraAperture	Animatable
filmOffset	Animatable
orthographic	Constant
orthographicWidth	Animatable

Camera Aperture defines the film size in inch, film Offset is also in inch.

When Orthographic is enabled, Focal Length, Camera Aperture and Film Offset have no effect in Maya.

Joint

A Skeleton is made up of joints

translate	Animatable
rotate	Animatable
scale	Animatable
rotateOrder	Constant
roateAxis	Constant
inheritsTransform	Constant
jointOrient	Constant
visibility	Animatable

Look At

Look At controller for camera

offset	Constant
aimVector	Constant
upVector	Constant
worldUpType	Constant
worldUpVector	Animatable
twist	Animatable

Twist only works for World Up Type = Scene or Vector.

Transform

Basic transform node

translate	Animatable
rotate	Animatable
scale	Animatable
shear	Animatable
rotateOrder	Constant
roateAxis	Constant
inheritsTransform	Constant
rotatePivot	Constant
scalePivot	Constant
visibility	Animatable

Geometry

Blend Shape

WebGL: will exceed maximum vertex inputs for more than one target.

One mesh per blend target is supported.

Mesh

Fully supported. Automatic triangulation is done on polygons, but the quality of Maya's triangulation may be better. Automatic vertex cache optimization is performed.

visibility

Animatable

Sine Deformer

amplitude	Animatable
wavelength	Animatable
offset	Animatable
lowBound	Animatable
highBound	Animatable

Skin Cluster

A maximum of 8 bones per vertex is the limit for performance reasons but can be extended on request.

Shading

Note: Maya defines transparency separately for all three color channels. Inka3D currently only uses the red component as monochrome transparency since current hardware shaders support only monochrome transparency. Maya applies the transparency to a pixel in the render target as follows:

Pixel = Transparency * Pixel

+ (1 – Transparency) * (Sum of Lights + Ambient Color) * Surface Color

+ Incandescence

Lambert

color	Animatable, Texture
transparency	Animatable, Texture (See Note)
ambientColor	Animatable, Texture
incandescence	Animatable, Texture
bumpMapping	Tangent Space Normal Texture

Phong

Inherits Lambert

cosinePower	Animatable, Texture
specularColor	Animatable, Texture
reflectivity	Animatable, Texture
reflectedColor	Animatable, Texture

PhongE

Inherits Lambert

roughness	Animatable, Texture
highlightSize	Animatable, Texture
whiteness	Animatable, Texture
specularColor	Animatable, Texture
reflectivity	Animatable, Texture
reflectedColor	Animatable, Texture

Blinn

Inherits Lambert

eccentricity	Animatable, Texture
specularRollOff	Animatable, Texture
specularColor	Animatable, Texture
reflectivity	Animatable, Texture
reflectedColor	Animatable, Texture

Anisotropic

Inherits Lambert

angle	Animatable, Texture
spreadX	Animatable, Texture
spreadY	Animatable, Texture
roughness	Animatable, Texture
fresnelIndex	Animatable, Texture
specularColor	Animatable, Texture
reflectivity	Animatable, Texture
reflectedColor	Animatable, Texture
anisotropicReflectivity	Not Supported, always off

Surface Shader

The surface shader is mainly for head-up-displays and therefore no lighting is applied to it. As a special feature all file textures that are only used by the surface shader do not get mipmaps.

outColor	Animatable, Texture
outTransparency	Animatable, Texture

Fog

Settable via Render Settings window, Maya Software tab, Render Options, Post Processing.

color	Animatable
saturationDistance	Animatable
useHeight	Constant
minHeight	Animatable
maxHeight	Animatable
distanceClipPlanes	Constant
fogNearDistance	Animatable
fogFarDistance	Animatable

Lighting

When light parameters are connected to a Texture, these projections are used:

Ambient Light	Spherical-Cylindrical
Directional Light	Planar
Point Light	Projective
Spot Light	Spherical

Ambient Light

color	Animatable, Texture
intensity	Animatable, Texture
ambientShade	Animatable

Directional Light, Point Light

color	Animatable, Texture
intensity	Animatable, Texture
emitDiffuse	Constant
emitSpecular	Constant
decayRate	Constant

Spot Light

color	Animatable, Texture
intensity	Animatable, Texture
emitDiffuse	Constant
emitSpecular	Constant
decayRate	Constant
coneAngle	Animatable
penumbraAngle	Animatable

Texturing

All textures have a 'Color Balance' section that can be used to modify the output:

defaultColor	Animatable, Texture
colorGain	Animatable, Texture
colorOffset	Animatable, Texture
alphaGain	Animatable, Texture
alphaOffset	Animatable, Texture
alphaIsLuminance	Constant

If Alpha Is Luminance is on, the outAlpha output is the luminance of the color component and the outTransparency output is the inverse luminance of the color component

From 'Effects' these attributes can be used:

invert

Constant

File Texture

References a texture by its file name.

imageName	Constant
useImageSequence	Constant
imageNumber	Animatable
frameOffset	Animatable
uvCoord	UV, Texture
outColor	Output
outAlpha	Output
outTransparency	Output

Animated textures are created by setting „Use Image Sequence“. Then right-click on Image Number and edit the script if necessary. The image sequence must be of the format name.#.ext (preferred) or name#.ext where # is the value of the frameExtension attribute of the file texture.

Example for image sequence:

MyAnimation.0.png

MyAnimation.1.png

MyAnimation.2.png

MyAnimation.3.png

…

Example expression for cyclic texture animation that changes once per second:

file1.frameExtension = time % 4;

As a special feature there is the distinction between normal and surface textures. Surface textures are textures that are used only by the Maya surface shader. Normal textures are rescaled to power of two, i.e. an image of 800x600 is rescaled to 512x512. The resolution of surface textures is arbitrary, but if it is not power of two it is clamped at the borders due to a limitation of WebGL. This is summarized in the following table:

Texture type	Resolution	Action	Mode
Standard	Power of two	Create mipmaps	Repeat
Standard	Non power of two	Rescale to power of two, create mipmaps	Repeat
Surface	Power of two	None	Repeat
Surface	Non power of two	None	Clamp

Possible power of two values for texture resolutions are: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096

Ramp Texture

Supported ramp types:

V Ramp

U Ramp

Diagonal Ramp

Radial Ramp

Circular Ramp

Box Ramp

Supported interpolation types:

None

Linear

Attributes:

uvCoord	UV, Texture
outColor	Output
outAlpha	Output

Checker Texture

color1	Animatable, Texture
color2	Animatable, Texture
contrast	Animatable, Texture
uvCoord	UV, Texture
outColor	Output
outAlpha	Output

Bulge Texture

uWidth	Animatable, Texture
vWidth	Animatable, Texture
uvCoord	UV, Texture
outColor	Output
outAlpha	Output

Layered Texture

All blend modes are supported.

Parameters per blend stage:

color	Animatable, Texture
alpha	Animatable, Texture
blendMode	Constant
layerIsVisible	Constant
outColor	Output
outAlpha	Output

Place2dTexture

coverage	Animatable, Texture, Correct when >= 1.0
translateFrame	Animatable, Texture
rotateFrame	Animatable, Texture
mirrorU	Constant
mirrorV	Constant
wrapU	Constant
wrapV	Constant
stagger	Constant
repeatUV	Animatable, Texture
offset	Animatable, Texture
rotateUV	Animatable, Texture
noiseUV	Not supported
uvCoord	Output

Env Ball

Environment ball. The environment is captured on a texture by taking a picture of a reflective ball that is inside the environment. The objects are given the appearance of the ball.

eyeSpace	Contant
reflect	Must be on
outColor	Output

Env Sphere

Environment sphere. The environment is created by mapping a texture on an infinitely large sphere. The reflection vectors on an object do a texture lookup on this sphere.

flip	Contant
outColor	Output

UV Chooser

Chooses the UV set for following texture in the shading network. To create/edit UV choosers use Window → Relationship Editors → UV Linking.

Vertex Colors

Vertex colors are supported via the Mental Ray vertex colors node. Use the mental ray renderer in maya to preview the result. Only red, green and blue of the vertex colors are exported, not the alpha channel.

mentalrayVertexColors

cpvSets[ ]	Constant
defaultColor	Animatable, Texture
colorGain	Animatable, Texture
colorOffset	Animatable, Texture
alphaGain	Animatable, Texture
alphaOffset	Animatable, Texture
alphaIsLuminance	On
invert	Constant
outColor	Output
outAlpha	Output

Particle Sampler

Particle attributes can be accessed inside a shading network with the particleSamplerInfo node. Currently only the uv output can be taken from the normalized age of the particles.

outUvType	Normalized Age
inverseOutUv	Constant

Use the particle sampler to animate the transparency or color of sprite particles over their life time. For example you can create a ramp texture, delete the place2dTexture node and connect outUvCoord of the particleSamplerInfo to uvCoord of the ramp texture.

Utility

Utility nodes can be used in a scene or in a shading network.

Add Double Linear

input1	Animatable, Texture
input2	Animatable, Texture
output	Output

Angle Between

vector1	Animatable, Texture
vector2	Animatable, Texture
angle	Output
axis	Output

Blend Colors

color1	Animatable, Texture
color2	Animatable, Texture
output	Output

Clamp

min	Animatable, Texture
max	Animatable, Texture
input	Animatable, Texture
output	Output

Condition

firstTerm	Animatable, Texture
secondTerm	Animatable, Texture
operation	Constant
colorIfTrue	Animatable, Texture
colorIfFalse	Animatable, Texture
output	Output

Contrast

value	Animatable, Texture
contrast	Animatable, Texture
bias	Animatable, Texture
outValue	Output

Gamma Correct

value	Animatable, Texture
gamma	Animatable, Texture
outValue	Output

Luminance

value	Animatable, Texture
outValue	Output

Mult Double Linear

input1	Animatable, Texture
input2	Animatable, Texture
output	Output

Multiply Divide

input1	Animatable, Texture
input2	Animatable, Texture
output	Output

PlusMinusAverage

input1D[ ]	Animatable, Texture
input2D[ ]	Animatable, Texture
input3D[ ]	Animatable, Texture
output1D	Output
output2D	Output
output3D	Output

Reverse

input	Animatable, Texture
output	Output

Sampler Info

This node works only inside a shading network. Only a few attributes are supported so far:

flippedNormal	Output
facingRatio	Output

Unit Conversion

This node is usually hidden by Maya

input	Animatable, Texture
output	Output

Particle Systems

Particle systems can currently only be rendered using sprites (set Particle Render Type to Sprites) or an Instancer (Geometry Replacement). As particles are simulated over time using acceleration and velocity it is not possible to let the time run backwards. If you export an .html file with a time range that is too short strange things happen if the time jumps back.

Particle System

Emission Attributes

maxCount	Constant, must be > 0
emissionInWorld	Constant

Lifespan Attributes

lifespanMode	Constant
lifespan	Animatable
lifespanRandom	Animatable

Time Attributes

surrentTime

Animatable

Instancer (Geometry Replacement)

Supported attributes: Position, Scale, Shear, Visibility, Object Index, Rotation. Rotation Type must be None, then Maya uses the particle attribute selected in Rotation as rotation.

Render Attributes

If Particle Render Type is set to Sprites, then these attributes are supported:

spriteScaleX	Animatable
spriteScaleY	Animatable
spriteTwist	Animatable

Per Particle (Array) Attributes

Not yet supported are Ramp Position, Ramp Velocity and Ramp Acceleration. All other attributes including custom attributes can be used in creation, before dynamics and after dynamics expression.

Instancer

rotationAngleUnits	Constant
rotationOrder	Constant
cycle	Constant
cycleStepUnit	Constant
cycleStep	Animatable

Field

All particle force fields have the following attributes:

magnitude	Animatable
attenuation	Animatable
useMaxDistance	Constant
maxDistance	Animatable

Air Field

Inherits Field

direction	Animatable
speed	Animatable

Drag Field

Inherits Field

useDirection	Constant
direction	Animatable

Newton

Inherits Field

minDistance

Animatable

Radial

Inherits Field

Uniform/Gravity

Inherits Field

direction

Animatable

Vortex

Inherits Field

axis	Animatable

Constraints and IK

Aim Constraint

Lets a node aim at a target

offset	Constant
aimVector	Constant
upVector	Constant
worldUpType	Constant (Scene Up or Vector)
worldUpVector	Animatable

IK Handle

Not supported for WebGL

Only ikRPsolver supported, IK solution is different from Maya for more than one intermediate joint. The position and scale of joints in an IK chain are considered constant by the IK solver (except position of root joint).

poleVector

Animatable

Orient Constraint

Transfers the orientation of one or multiple nodes to another node

offset

Constant

Parent Constraint

Transfers the transformation of one or multiple nodes to another node

Point Constraint

Transfers the position of one or multiple nodes to another node

offset

Constant

Pole Vector Constraint

Lets the pole vector of a IK Handle point at a node

offset

Constant

Scale Constraint

Transfers the scale of one or multiple nodes to another node

offset

Constant

Limitations

Number of bones	1300, float texture used if more than 75
Number of blend shapes	4
Number of polygons per mesh	Limit removed in Inka3D 1.5
Sprite particle size	64 x 64 pixels in some browsers
Texture size	4096 x 4096 should not be exceeded

Meshes should be triangulated in maya as Inka3D's triangulation currently fails for concave polygons. Use Mesh->Triangulate.

User defined normals are exported only for static meshes, i.e. meshes without bones or deformers etc. This may lead to faceted apearance if the polygon edges are hard edges but only look smooth because of user defined normals.

Contents

Installation

Maya plugin

First test

Troubleshooting

API

HTML Header

Initialization

Renderer and render groups

Start loading

Observing load progress

Creating scenes

Interfacing scenes

Setting attributes

Getting attributes

Main loop

Update

Rendering

Picking

Export options

Interface Nodes

Interface Transforms

Interface Locators

Interface Cameras

Interface Lights

Export Render Layers

Add Pick Layer

No Bump Mapping

No Pixel Processing

Supported Maya Features

Scene

AnimCurve

Expression

Camera

Joint

Look At

Transform

Geometry

Blend Shape

Mesh

Sine Deformer

Skin Cluster

Shading

Lambert

Phong

PhongE

Blinn

Anisotropic

Surface Shader

Fog

Lighting

Ambient Light

Directional Light, Point Light

Spot Light

Texturing

File Texture

Ramp Texture

Checker Texture

Bulge Texture

Layered Texture

Place2dTexture

Env Ball

Env Sphere

UV Chooser

Vertex Colors

mentalrayVertexColors

Particle Sampler

Utility

Add Double Linear

Angle Between

Blend Colors

Clamp

Condition

Contrast

Gamma Correct

Luminance

Mult Double Linear

Multiply Divide

PlusMinusAverage

Reverse