Globals: Channel Info

Channel Info

Availability  LightWave 6.0
Component  Layout, Modeler
Header  lwenvel.h

A channel is an animation parameter that varies as a function of time. In contrast to envelopes, which are arrays of keys, channels may include the effects of other plug-ins and calculations. The channel info global gives you access to Layout's list of grouped channels. A channel's underlying envelope data may also be read (see the Animation Envelopes page for more information).

Global Call

   LWChannelInfo *chaninfo;
   chaninfo = global( LWCHANNELINFO_GLOBAL, GFUSE_TRANSIENT );

The global call returns a pointer to an LWChannelInfo.

   typedef struct st_LWChannelInfo {
      LWChanGroupID (*nextGroup)       (LWChanGroupID parent,
                                          LWChanGroupID group);
      LWChannelID   (*nextChannel)     (LWChanGroupID, LWChannelID);
      const char *  (*groupName)       (LWChanGroupID); 
      const char *  (*channelName)     (LWChannelID); 
      LWChanGroupID (*groupParent)     (LWChanGroupID); 
      LWChanGroupID (*channelParent)   (LWChannelID); 
      int           (*channelType)     (LWChannelID); 
      double        (*channelEvaluate) (LWChannelID, LWTime); 
      const LWEnvelopeID (*channelEnvelope) (LWChannelID); 
      int           (*setChannelEvent) (LWChannelID,
                                          LWChanEventFunc, void *); 
      const char *  (*server)          (LWChannelID, const char *class,
                                          int index);
      unsigned int  (*serverFlags)     (LWChannelID, const char *class,
                                          int index );
      LWInstance    (*serverInstance)  (LWChannelID, const char *class,
                                          int index );
      int           (*serverApply)     (LWChannelID, const char *class,
                                          const char *name, int flags );
      void          (*serverRemove)    (LWChannelID, const char *class,
                                          const char *name, LWInstance);
   } LWChannelInfo;

group = nextGroup( parent_group, prev_group )

Returns the next channel group in the group list. If the parent is NULL, this returns groups from the root of the channel tree, and if the previous group is NULL, it returns the first group.

channel = nextChannel( group, prev_channel )

Returns the next channel in the group. If the previous channel is NULL, this returns the first channel in the group.

gname = groupName( group )

Returns the name of the channel group.

cname = channelName( channel )

Returns the name of the channel.

parent = groupParent( group )

Returns the parent group of a channel group.

parent = channelParent( channel )

Returns the group a channel belongs to.

type = channelType( channel )

Returns the value type of the channel, which determines how the value is interpreted and displayed to the user. It can be one of the following.

LWET_FLOAT
LWET_DISTANCE
LWET_PERCENT
LWET_ANGLE

value = channelEvaluate( channel, time )

Returns the value of the channel at the specified time.

envelope = channelEnvelope( channel )

Returns the underlying envelope for a channel. The envelope can be examined and modified using the Animation Envelopes global.

result = setChannelEvent( channel, event_func, data )

Set a callback for a channel. Whenever the channel's underlying envelope is modified, your event_func function will be called with data as its first argument. The result is true (non-zero) if the function succeeds and false (0) if it fails. The callback receives the same event codes as the envelope global's setEnvEvent function, plus LWCEVNT_VALUE.

servname = server( channel, class, index )

Returns the name of a plug-in applied to the channel. The class argument is the class string, which will often be LWCHANNEL_HCLASS but may be others. The index specifies the "slot," or position in the server list, and counts from 1.

flags = serverFlags( channel, class, index )

Returns flags for the plug-in applied to the channel. This is the channel-specific version of the Item Info serverFlags function.

instance = serverInstance( channel, class, index )

Returns an opaque pointer to the plug-in's instance data. This is the LWInstance created and used by the plug-in's LWInstanceFuncs callbacks.

index = serverApply( channel, class, name, flags )

Apply the plug-in to the channel. Returns the server list index, or 0 if it fails. The name is the server name, the string in the name field of the plug-in's ServerRecord. The flags can be any combination of those returned by serverFlags.

serverRemove( channel, class, name, instance )

Remove the plug-in from the channel. The instance is the pointer returned by serverInstance.

History

In LightWave 7.0, the service name for this global was incremented from "Channel Info" to "Channel Info 2", and the serverFlags, serverInstance, serverApply and serverRemove functions were added, along with the LWCEVNT_VALUE event code.

Example

The find_channels function finds all of the channels belonging to a group and prints the name and type of each channel. It calls itself recursively to examine the subgroups of the parent group.

   #include <lwserver.h>
   #include <lwenvel.h>

   static void find_channels( LWChannelInfo *chinfo,
      LWChanGroupID parent, int indent )
   {
      LWChanGroupID group;
      LWChannelID chan;

      group = chinfo->nextGroup( parent, NULL );
      while ( group ) {
         printf( "%*s(G) \"%s\"\n", indent, " ",
            chinfo->groupName( group ));
         find_channels( chinfo, group, indent + 2 );
         chan = chinfo->nextChannel( group, NULL );
         while ( chan ) {
            printf( "%*s(C) \"%s\" type %d\n", indent + 2, " ",
               chinfo->channelName( chan ),
               chinfo->channelType( chan ));
            chan = chinfo->nextChannel( group, chan );
         }
         group = chinfo->nextGroup( parent, group );
      }
   }