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.
// ==========================================================================
//+

//
//  File: latticeNoise.cc
//
//  Description:
//      plugin registration code
//

#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];