latticeNoise/latticeNoise.cpp

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

// DESCRIPTION:
// 
// Produces the dependency graph node "latticeNoise" and MEL command "latticeNoise".
//
// This plug-in is an example of the following:
//
//  - how to have node attributes input and output geometry
//  - how to modify dependency graph connections using the API
//  - how to take Maya objects as arguments to a user defined MEL command
//
// The "latticeNoise" command creates a new lattice deformer around the currently selected geometry
// or around the objects specified on the command line. The command also inserts a "latticeNoise" node
// in between the lattice shape in the DAG and the node that performs the deformation.
//
// The end effect of the "latticeNoise" command is that the objects inside the lattice deform
// with respect to the lattice, but they also wobble about randomly as noise is applied to the lattice points.
// The "latticeNoise" node has attributes for amplitude and frequency that control the amount of noise applied.
//
// An example of using the command is:
//
//  latticeNoise nurbsSphereShape1 nurbsConeShape1;
//

#include "latticeNoise.h"
#include <maya/MFnPlugin.h>
#include <maya/MString.h>
#include <stdlib.h>

MStatus initializePlugin( MObject obj )
{
    MStatus   status;
    MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");

    // Register latticeNoise node
    //
    status = plugin.registerNode( "latticeNoise", latticeNoiseNode::id,
                                         latticeNoiseNode::creator,
                                         latticeNoiseNode::initialize);
    if (!status) {
        status.perror("registerNode");
        return status;
    }

    // Register latticeNoise command
    //
    status = plugin.registerCommand( "latticeNoise", latticeNoiseCmd::creator );
    if (!status) {
        plugin.deregisterNode( latticeNoiseNode::id );
        status.perror("registerCommand");
        return status;
    }

    return status;
}

MStatus uninitializePlugin( MObject obj)
{
    MStatus   status;
    MFnPlugin plugin( obj );

    // Deregister latticeNoise node
    //
    status = plugin.deregisterNode( latticeNoiseNode::id ); 
    if (!status) {
        status.perror("registerNode");
        return status;
    }

    // Register latticeNoise command
    //
    status = plugin.deregisterCommand( "latticeNoise" ); 
    if (!status) {
        status.perror("deregisterCommand");
        return status;
    }

    return status;
}

//
//  Class: noise
//
//  Description:
//      The noise class is used for generating pseudo-random continuous noise.
//      The noise values generated are always between 0 and 1.
//
//      The technique used is a simple lattice noise algorithm based upon one 
//      by Ken Perlin.  This particular implementation is adapted from 
//      Darwyn Peachey's (Texturing and Modeling: a Procedural Approach, S. Ebert
//      Editor, 1994).
//
#include <stdlib.h>
#include <math.h>

const int kTableMask = TABLE_SIZE - 1;



//                       PUBLIC                             //

float noise::atValue( float x )
//
//  Description:
//      Get the noise value at the given point in 1-space.
//
//  Arguments:
//      x - the point at which to calculate the noise
//
//  Return Value:
//      the noise value at the point
//
{
    int ix; 
    float fx; 

    if ( !isInitialized ) {
        initTable( 23479015 );
        isInitialized = 1;
    }

    ix = (int)floorf( x );
    fx = x - (float)ix; 
 
    return spline( fx, value( ix - 1 ),
                       value( ix ),
                       value( ix + 1 ),
                       value( ix + 2 ) );
}

float noise::atPoint( float x, float y, float z )
//
//  Description:
//      Get the noise value at the given point in 3-space.
//
//  Arguments:
//      x - x component of point
//      y - x component of point
//      z - x component of point
//
//  Return Value:
//      the noise value at the point
//
{
    int ix, iy, iz;
    int i, j, k;
    float fx, fy, fz;
    float xknots[4], yknots[4], zknots[4];

    if ( !isInitialized ) {
        initTable( 23479015 );
    }

    ix = (int)floorf( x );
    fx = x - (float)ix; 

    iy = (int)floorf( y );
    fy = y - (float)iy;

    iz = (int)floorf( z );
    fz = z - (float)iz;

    for ( k = -1; k <= 2; k++ ) {
        for ( j = -1; j <= 2; j++ ) {
            for ( i = -1; i <= 2 ; i++ ) {
                xknots[i+1] = value( ix + i, iy + j, iz + k );
            }
            yknots[j+1] = spline( fx, xknots[0], xknots[1], xknots[2], xknots[3] );
        }
        zknots[k+1] = spline( fy, yknots[0], yknots[1], yknots[2], yknots[3] );
    }

    float val = spline( fz, zknots[0], zknots[1], zknots[2], zknots[3] ); 

    return val;
}

pnt noise::atPointAndTime( float x, float y, float z, float t )
//
//  Description:
//      Get three noise values at the given point in 4-space.  This is actually
//      a reasonably expensive operation.  It requires 255 simple spline 
//      interpolations.  However, the noise function is continuous. 
//
//  Arguments:
//      x - x component of point
//      y - x component of point
//      z - x component of point
//      t - t component of point (time component)
//
//  Return Value:
//      the noise value at the point
//
{
    pnt ret;
    
    int ix, iy, iz, it;
    int i, j, k, l;
    float fx, fy, fz, ft;
    float xknots[3][4], yknots[3][4], zknots[3][4], tknots[3][4];

    if ( !isInitialized ) {
        initTable( 23479015 );
    }

    ix = (int)floorf( x );
    fx = x - (float)ix; 

    iy = (int)floorf( y );
    fy = y - (float)iy;

    iz = (int)floorf( z );
    fz = z - (float)iz;

    it = (int)floorf( t);
    ft = t - (float)it;

    for ( l = -1; l <= 2; l++ ) {
        for ( k = -1; k <= 2; k++ ) {
            for ( j = -1; j <= 2; j++ ) {
                for ( i = -1; i <= 2 ; i++ ) {
                    xknots[0][i+1] = value( ix + i, iy + j, iz + k, it + l,
                                            valueTable1 ); 
                    xknots[1][i+1] = value( ix + i, iy + j, iz + k, it + l,
                                            valueTable2 ); 
                    xknots[2][i+1] = value( ix + i, iy + j, iz + k, it + l,
                                            valueTable3 ); 
                }
                yknots[0][j+1] = spline( fx, xknots[0][0], xknots[0][1], 
                                         xknots[0][2], xknots[0][3] );
                yknots[1][j+1] = spline( fx, xknots[1][0], xknots[1][1], 
                                         xknots[1][2], xknots[1][3] );
                yknots[2][j+1] = spline( fx, xknots[2][0], xknots[2][1], 
                                         xknots[2][2], xknots[2][3] );
            }
            zknots[0][k+1] = spline( fy, yknots[0][0], yknots[0][1], 
                                     yknots[0][2], yknots[0][3] );
            zknots[1][k+1] = spline( fy, yknots[1][0], yknots[1][1], 
                                     yknots[1][2], yknots[1][3] );
            zknots[2][k+1] = spline( fy, yknots[2][0], yknots[2][1], 
                                     yknots[2][2], yknots[2][3] );
        }
        tknots[0][l+1] = spline( fz, zknots[0][0], zknots[0][1], 
                                 zknots[0][2], zknots[0][3] );
        tknots[1][l+1] = spline( fz, zknots[1][0], zknots[1][1], 
                                 zknots[1][2], zknots[1][3] );
        tknots[2][l+1] = spline( fz, zknots[2][0], zknots[2][1], 
                                 zknots[2][2], zknots[2][3] );
    } 
    ret.x = spline( ft, tknots[0][0], tknots[0][1], tknots[0][2], tknots[0][3] ); 
    ret.y = spline( ft, tknots[1][0], tknots[1][1], tknots[1][2], tknots[1][3] ); 
    ret.z = spline( ft, tknots[2][0], tknots[2][1], tknots[2][2], tknots[2][3] ); 

    return ret;
}
 

void  noise::initTable( long seed )
//
//  Description:
//      Initialize the table of random values with the given seed. 
//
//  Arguments:
//      seed - the new seed value 
//
{
    srand48( seed );

    for ( int i = 0; i < TABLE_SIZE; i++ ) {
        valueTable1[i] = (float)drand48();
        valueTable2[i] = (float)drand48();
        valueTable3[i] = (float)drand48();
    } 
    isInitialized = 1; 
}



//                       PRIVATE                            //
 

float noise::spline( float x, float knot0, float knot1, float knot2, float knot3 )
//
//  Description:
//      This is a simple version of a Catmull-Rom spline interpolation.  
//
//  Assumptions:
//      
//      0 < x < 1
// 
//
{
    float c0, c1, c2, c3;

    // Evaluate span of cubic at x using Horner's rule
    //
    c3 = (-0.5F * knot0 ) + ( 1.5F * knot1 ) + (-1.5F * knot2 ) + ( 0.5F * knot3 );
    c2 = ( 1.0F * knot0 ) + (-2.5F * knot1 ) + ( 2.0F * knot2 ) + (-0.5F * knot3 );
    c1 = (-0.5F * knot0 ) + ( 0.0F * knot1 ) + ( 0.5F * knot2 ) + ( 0.0F * knot3 );
    c0 = ( 0.0F * knot0 ) + ( 1.0F * knot1 ) + ( 0.0F * knot2 ) + ( 0.0F * knot3 );
          
    return ( ( c3 * x + c2 ) * x + c1 ) * x + c0;;
}


int noise::isInitialized = 0;

int noise::permtable[256] = {
    254,    91,     242,    186,    90,     204,    85,     133,    233,
    50,     187,    49,     182,    224,    144,    166,    7,      51,
    20,     179,    36,     203,    114,    156,    195,    40,     24,
    60,     162,    84,     126,    102,    63,     194,    220,    161,
    72,     94,     193,    229,    140,    57,     3,      189,    106,
    54,     164,    198,    199,    44,     245,    235,    100,    87,
    25,     41,     62,     111,    13,     70,     27,     82,     69,
    53,     66,     247,    124,    67,     163,    125,    155,    228,
    122,    19,     113,    143,    121,    9,      1,      241,    171,
    200,    83,     244,    185,    170,    141,    115,    190,    154,
    48,     32,     178,    127,    167,    56,     134,    15,     160,
    238,    64,     6,      11,     196,    232,    26,     89,     0,
    219,    112,    68,     30,     215,    227,    75,     132,    71,
    239,    251,    92,     14,     104,    231,    29,     180,    150,
    226,    191,    47,     73,     37,     183,    88,     105,    42,
    22,     2,      38,     5,      119,    74,     249,    184,    52,
    8,      55,     118,    255,    206,    173,    165,    78,     31,
    123,    98,     212,    80,     139,    61,     138,    77,     177,
    45,     137,    145,    28,     168,    128,    95,     223,    35,
    205,    76,     211,    175,    81,     33,     207,    21,     131,
    58,     152,    16,     240,    18,     96,     210,    109,    214,
    216,    202,    148,    34,     146,    117,    176,    93,     246,
    172,    97,     159,    197,    218,    65,     147,    253,    221,
    217,    79,     101,    142,    23,     149,    99,     39,     12,
    135,    110,    234,    108,    153,    129,    4,      169,    174,
    116,    243,    130,    107,    222,    10,     43,     188,    46,
    213,    252,    86,     157,    192,    236,    158,    120,    17,
    103,    248,    225,    230,    250,    208,    181,    151,    237,
    201,    59,     136,    209 
};

float noise::valueTable1[256];
float noise::valueTable2[256];
float noise::valueTable3[256];