Eagle517/tge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added everything

Browse Source
This commit is contained in:
Metario
2017-04-17 06:17:10 -06:00
commit 9c6ff74f19
6121 changed files with 1625704 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

697
lib/maxsdk31/filters.h Executable file
View File

@@ -0,0 +1,697 @@
//-----------------------------------------------------------------------------
// --------------------
// File ....: Filters.h
// --------------------
// Author...: Gus Grubba
// Date ....: September 1995
//
// History .: Sep, 07 1995 - Started
//
//-----------------------------------------------------------------------------
#ifndef FILTERS_H_DEFINED
#define FILTERS_H_DEFINED
#include <fltapi.h>
#include <tvnode.h>
//-- Just to make it shorter
#define dVirtual FLTExport virtual
//-- How long can a filter name be
#define MAXFILTERNAME MAX_PATH
#define MAXRESOURCE MAX_PATH
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Frame Range
//
class FrameRange {
int start;
int end;
int current;
public:
FLTExport FrameRange ( ) {start = end = current = 0;}
FLTExport ~FrameRange ( ) {};
FLTExport int First ( ) { return (start); }
FLTExport int Last ( ) { return (end); }
FLTExport int Count ( ) { return (end - start + 1); }
FLTExport int Current ( ) { return (current); }
FLTExport int Elapsed ( ) { return (current - start); }
FLTExport void SetFirst ( int u ) { start = u; }
FLTExport void SetLast ( int u ) { end = u; }
FLTExport void SetCurrent ( int u ) { current = u; }
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Forward Reference
class ImageFilter;
class FilterManager;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Time Change Notification (R2)
class TimeChange : public TimeChangeCallback {
public:
BOOL set;
TimeChange () { set = FALSE; }
ImageFilter *filter;
void TimeChanged(TimeValue t);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Filter Info
//
enum MaskType {
MASK_R = 0,
MASK_G,
MASK_B,
MASK_A,
MASK_L,
MASK_Z,
MASK_MTL_ID,
MASK_NODE_ID
};
#define NUMMASKFLAGS (MASK_NODE_ID - MASK_R) + 1
class ImageFilterInfo {
//-- Name of the filter used internally for identitification.
TCHAR name[MAXFILTERNAME];
//-- Filters may want to identify themselves by something more
// specific than their names. Specially filters that give names
// to parameter sets. If "resource" below is not empty, it
// will be used to identify the filter in the Video Post Queue.
// This is saved along with everything else by the host (Max).
// If all the filter needs is a resource to identify a set of
// parameters, this will sufice.
TCHAR resource[MAXRESOURCE];
//-- Plug-In Parameter Block ------------------------------------------
//
// No direct access to clients. Use the methods in the filter class.
//
void *pidata;
DWORD pisize;
//-- New R2 Stuff
TCHAR *userlabel; //-- Optional label given by user
ITrackViewNode *node; //-- TV Node (if any)
Class_ID nodeid; //-- TV Node ID (if any);
int flttype;
public:
FLTExport ImageFilterInfo ( );
FLTExport ~ImageFilterInfo ( );
//-- Mask Information -------------------------------------------------
BOOL maskenabled,evCopy;
BOOL invertedmask;
BitmapInfo mask;
WORD maskflag;
//-- This is a BitmapInfo that holds information about the current
// Video Post main queue Image buffer. This can be used to get
// VP's (or target image) resolution, etc. To make an analogy, if
// this was a BitmapIO plug-in, this is the BitmapInfo given as
// the argument. This used primarilly at the time the filter
// receives the "Setup()" call as at render time, all this can be
// found in srcmap.
BitmapInfo imgQueue;
//-- Internal Helpers -------------------------------------------------
FLTExport void SetName ( const TCHAR *n ) { _tcscpy(name,n);}
FLTExport void SetResource ( const TCHAR *n ) { _tcscpy(resource,n);}
FLTExport const TCHAR *Name ( ) { return (const TCHAR *)name;}
FLTExport const TCHAR *Resource ( ) { return (const TCHAR *)resource;}
//-- Plug-In Parameter Block ------------------------------------------
FLTExport void *GetPiData ( ) { return pidata; }
FLTExport void SetPiData ( void *ptr ) { pidata = ptr; }
FLTExport DWORD GetPiDataSize ( ) { return pisize; }
FLTExport void SetPiDataSize ( DWORD s ) { pisize = s; }
FLTExport void ResetPiData ( );
FLTExport BOOL AllocPiData ( DWORD size );
FLTExport ImageFilterInfo &operator= ( ImageFilterInfo &from );
//-- Load/Save
FLTExport IOResult Save ( ISave *isave );
FLTExport IOResult Load ( ILoad *iload, Interface *max );
//-- Execution Info ---------------------------------------------------
//
// 12/06/95 - GG
//
// QueueRange defines the entire Video Post Queue range. Execution
// is only the portion being rendered. This is, unless the user selects
// a "range", the same as QueueRange. FilterRange is where this filter
// starts and ends.
//
// Video Post Queue
//
// 1 2 3 4 5
// 0----|----|----|----|----|----|----|----|----|----|----|----|----|---- ...
//
// Video Post spans from 0 to 49 (QueueRange) Start: 0 End: 49
//
// qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
//
// User executes a "range" from 10 to 30 (Execution Range) Start: 10 End: 30
//
// uuuuuuuuuuuuuuuuuuuuu
//
// This filter appears in the queue from 5 to 35 (Filter Range) Start: 5 End: 35
//
// fffffffffffffffffffffffffffffff
FrameRange QueueRange; //-- Entire Video Post Queue
FrameRange ExecutionRange; //-- Segement being rendered
FrameRange FilterRange; //-- Filter Segment
//----------------------------------------------------------------------
//-- R2 Stuff Below ----------------------------------------------------
//----------------------------------------------------------------------
//-- Trackview Node Functions ------------------------------------------
FLTExport ITrackViewNode *Node ( ) { return node; }
FLTExport void SetNode (ITrackViewNode *n) { node = n; }
FLTExport Class_ID NodeID ( ) { return nodeid;}
FLTExport void SetNodeID ( Class_ID id ) { nodeid = id; }
//-- Optional Label given by user while adding or editing a filter. This label
// replaces the filter's name in Video Post's tracks for easier identification.
FLTExport TCHAR *UserLabel ( ) { return userlabel; }
//-- Used by VP to update the label. Not to be used by filters.
FLTExport void SetUserLabel ( TCHAR *l) { userlabel = l; }
//-- Used to determine what type of filter this is at "Setup" time.
#define FLT_FILTER 0
#define FLT_LAYER 1
FLTExport int FilterType ( ) { return flttype; }
FLTExport void SetFilterType ( int type ) { flttype = type; }
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Filter Plug-Ins Handler
//
class FLT_FilterHandler {
//-- Name and Capabilities ------------------------
TCHAR fltDescription[MAXFILTERNAME];
DWORD fltCapability;
//-- DLL Handler ----------------------------------
ClassDesc *cd;
public:
FLT_FilterHandler();
FLTExport TCHAR *Description ( const TCHAR *d = NULL );
FLTExport void SetCD ( ClassDesc *dll ) { cd = dll;}
FLTExport ClassDesc *GetCD ( ) { return cd;}
FLTExport void SetCapabilities ( DWORD cap ) { fltCapability |= cap;}
FLTExport DWORD GetCapabilities ( ) { return (fltCapability);}
FLTExport BOOL TestCapabilities ( DWORD cap ) { return (fltCapability & cap);}
};
//-----------------------------------------------------------------------------
//-- Messages sent back by various (client) methods
//-- Sent by the plug-in to notify host of current progress. The host should
// return TRUE if it's ok to continue or FALSE to abort process.
#define FLT_PROGRESS WM_USER + 0x20 //-- wParam: Current lParam: Total
//-- Sent by the plug-in to check for process interruption. The host should
// return FALSE (by setting *lParam) if it's ok to continue or TRUE to abort
// process.
#define FLT_CHECKABORT WM_USER + 0x21 //-- wParam: 0 lParam: BOOL*
//-- Sent by the plug-in to display an optional textual message (for progress
// report).
#define FLT_TEXTMSG WM_USER + 0x22 //-- wParam: 0 lParam: LPCTSTR
//-- Sent by the host TO the plug-in to notify the time has changed (the user
// moved the time slider in Max).
#define FLT_TIMECHANGED WM_USER + 0x23 //-- wParam: 0 lParam: TimeValue t
//-- Sent by the host TO the plug-in to notify that an Undo operation has been done.
// The plugin will set some boolean internally and wait for the next WM_PAINT message
// in order to update any spinners or other values that may have been undone.
#define FLT_UNDO WM_USER + 0x24 //-- wParam: 0 lParam: 0
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- List of Filter Plug-Ins
//
class FLT_FilterList: public Tab<FLT_FilterHandler> {
BOOL listed;
public:
FLT_FilterList ( ) { listed = FALSE; }
BOOL Listed ( BOOL f) { listed = f; return (listed);};
BOOL Listed ( ) { return (listed);};
FLTExport int FindFilter ( const TCHAR *name );
FLTExport DWORD GetFilterCapabilities ( const TCHAR *name );
//-- This Creates an Instance - Make sure to "delete" it after use.
FLTExport ImageFilter *CreateFilterInstance(const TCHAR *d);
};
//-----------------------------------------------------------------------------
//-- Undo Notification
class UndoNotify : public TVNodeNotify {
HWND hWnd;
public:
UndoNotify (HWND hwnd) {hWnd = hwnd;}
RefResult NotifyRefChanged (Interval changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message) {
SendMessage(hWnd,FLT_UNDO,0,0);
InvalidateRect(hWnd,NULL,FALSE);
return(REF_SUCCEED);
}
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- ImageFilter Capability Flags
//
// It is valid for a plug-in to both Filter and Compositor. If both flags are
// set, the user will be able to select it from both the Filter list and from
// the Compositor list. The plug-in will know it is running as a filter when
// the foreground map pointer is NULL.
//
#define IMGFLT_NONE 0 // None
#define IMGFLT_MASK (1<<0) // Supports Masking
#define IMGFLT_CONTROL (1<<1) // Plug-In has a Control Panel
#define IMGFLT_FILTER (1<<2) // Plug-In is a Filter
#define IMGFLT_COMPOSITOR (1<<3) // Plug-In is a Compositor
#define IMGFLT_THREADED (1<<4) // Thread aware plug-in
//-- Class ID's for various DLL's
#define NEGATIVECLASSID 0x4655434A
#define ALPHACLASSID 0x655434A4
#define ADDCLASSID 0x55434A46
#define BLURCLASSID 0x5434A465
#define CROSFADECLASSID 0x434A4655
#define GLOWCLASSID 0x35A46554
#define COOKIECLASSID 0x4A465543
#define WIPECLASSID 0xA4655434
#define FADECLASSID 0x4655434B
#define PDALPHACLASSID 0x655434B4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Image Filter Class
//
class ImageFilter {
protected:
BOOL interactive;
HWND vpSetuphWnd,vphWnd,dlghWnd;
//-- Bitmap Pointers --------------------------------------------------
//
// All filters will have at least a pointer to "srcmap". This is VP's
// (or any other process') main image pipeline.
//
// Composition filters will also receive a second [frgmap] bitmap
// which should be composited above the main [srcmap] bitmap.
//
// If "mskmap" is not NULL, it will contain a pointer to a grayscale
// image to be used as a mask for the process.
//
// 12/06/95 - GG
//
// The srcmap (Background) is the Video Post queue bitmap. Use its
// methods to find out dimmensions (width, height, aspect ratio, etc.)
// If the queue is using Alpha channel, it will be noted in the bitmap
// flags (srcmap). The same is true for Z and G buffers. Again, simply
// use the bitmap methods to access these.
//
Bitmap *srcmap; //-- Source (Background)
Bitmap *mskmap; //-- Mask (Grayscale Masking)
Bitmap *frgmap; //-- Foreground (for layering/transitions)
//-- Set by Host ----------------------------------
ImageFilterInfo *ifi;
public:
FLTExport ImageFilter ( );
dVirtual ~ImageFilter ( );
//-- Filter Info ---------------------------------
dVirtual const TCHAR *Description ( ) = 0; // ASCII description (i.e. "Convolution Filter")
dVirtual const TCHAR *AuthorName ( ) = 0; // ASCII Author name
dVirtual const TCHAR *CopyrightMessage ( ) = 0; // ASCII Copyright message
dVirtual UINT Version ( ) = 0; // Version number * 100 (i.e. v3.01 = 301)
dVirtual DWORD Capability ( ) = 0; // Returns capability flags (see above)
//-- Dialogs ----------------------------------------------------------
//
// An About Box is mandatory. The Control panel is optional and its
// existence should be flagged by the Capability flag above.
//
dVirtual void ShowAbout ( HWND hWnd ) = 0;
dVirtual BOOL ShowControl ( HWND hWnd ) { return FALSE; }
//-- Parameter Setting (Host's Responsability) ----
dVirtual void SetSource ( Bitmap *map ) {srcmap = map;}
dVirtual void SetForeground ( Bitmap *map ) {frgmap = map;}
dVirtual void SetMask ( Bitmap *map ) {mskmap = map;}
dVirtual void SetFilterInfo ( ImageFilterInfo *i ) {ifi = i;}
//-- Execution ------------------------------------
//
// The "hWnd" argument is a window handler to which
// the plug-in will be sending messages.
dVirtual BOOL Render ( HWND hWnd ) = 0;
//-- Max Interface ----------------------------------------------------
//
// Some of Max's core functions exported through the Interface class.
//
dVirtual Interface *Max ( );
//-- Helpers --------------------------------------
dVirtual int Lerp (int a, int b, int l);
dVirtual int Lerp (int a, int b, float f);
//-- Parameter Block Load and Save ------------------------------------
//
// The host will call EvaluateConfigure() to determine the buffer size
// required by the plug-in.
//
// SaveConfigure() will be called so the plug-in can transfer its
// parameter block to the host ( ptr is a pre-allocated buffer).
//
// LoadConfigure() will be called so the plug-in can load its
// parameter block back.
//
// Memory management is performed by the host using standard
// LocalAlloc() and LocalFree().
//
dVirtual DWORD EvaluateConfigure ( ) { return 0; }
dVirtual BOOL LoadConfigure ( void *ptr ) { return (FALSE); }
dVirtual BOOL SaveConfigure ( void *ptr ) { return (FALSE); }
//-- Preview Facility -------------------------------------------------
//
// This is used by plug-ins that want to have a preview bitmap while
// displaying its control dialogue.
//
// The flag controls how much of the queue to run:
//
// PREVIEW_BEFORE - The queue is run up to the event before the filter
// calling it.
//
// PREVIEW_UP ----- The queue is run up to the event (filter) calling
// this function.
//
// PREVIEW_WHOLE -- The whole queue is run including events after
// this filter.
//
// The given frame is the Video Post Queue frame number and not Max's
// frame number.
//
//
// Parameters:
//
// hWnd - WIndow handle to send messages to. These are the progress,
// check for abort, text messages etc. If the plug in wants to support
// a cancel button and progress bars etc, it must handle these messages.
// It is Ok to send a NULL window handle in which case nothing is checked.
//
// back - Pointer to a Bitmap pointer. If the Bitmap pointer is NULL, a
// new bitmap is created using the given dimmensions. This pointer must be
// NULL the first time this function is called as the bitmap must be
// created by Video Post. Once this function is called and a bitmap is
// returned, it is ok to call it again using this map. In this case, Video
// Post will simply use it instead of creating a new one. You must delete
// the bitmap when done.
//
// fore - For layer plug-ins, this points to the foreground image. This is
// only valid if flag is set to PREVIEW_BEFORE. In this case back will hold
// Video Post main queue and fore will have the foreground image to be
// composited. This is usefull if you, a layer plug-in, want to collect the
// images and run a real time preview. If flag is not PREVIEW_BEFORE, fore
// will be a NULL pointer indicating there is no bitmap.
//
// frame - The desired frame. Make sure you request a frame within the
// range your plug-in is active.
//
// width & height - Self explanatory.
//
// flag - Explained above.
//
#ifndef PREVIEW_BEFORE
#define PREVIEW_BEFORE 1
#define PREVIEW_UP 2
#define PREVIEW_WHOLE 3
#endif
dVirtual BOOL CreatePreview (
HWND hWnd, //-- Window handle to send messages to
Bitmap **back, //-- Pointer to Bitmap Pointer (Background)
int frame, //-- Desired Frame
int width, //-- Desired Width
int height, //-- Desired Height
float aspect, //-- Desired Aspect Ratio
Bitmap **fore = NULL, //-- Pointer to Bitmap Pointer (Foreground)
DWORD flag = PREVIEW_UP );
//----------------------------------------------------------------------
//-- Channels Required
//
// By setting this flag, the plug-in can request the host to generate
// the given channels. Prior to Rendering, the host will scan the
// plug-ins in the chain of events and list all types of channels
// being requested. The plug-in, at the time of the Render() call,
// will have access to these channels through the channel interface
// described in Bitmap.h - BitmapStorage.
//
// The generation of these channels should not, normally, be a
// default setting for a plug-in. These channels are memory hungry and
// if the plug-in won't use it, it should not ask for it. Normally
// the plug-in would ask the user which channels to use and set only
// the proper flags.
//
dVirtual DWORD ChannelsRequired ( ) { return BMM_CHAN_NONE; }
//----------------------------------------------------------------------
//-- R2 Stuff Below ----------------------------------------------------
//----------------------------------------------------------------------
TimeChange timeChange;
UndoNotify* undonotify;
dVirtual HWND DlgHandle ( void ) { return dlghWnd; }
//-- Filter Control Dialogue Interactivity -----------------------------
dVirtual void MakeDlgInteractive ( HWND hWnd );
dVirtual BOOL IsInteractive ( void ) { return interactive; }
//-- Trackview Node Functions ------------------------------------------
dVirtual ITrackViewNode *CreateNode ( );
dVirtual ITrackViewNode *Node ( ) { return ifi->Node(); }
//-- FilterUpdate() ----------------------------------------------------
//
// Whenever a filter instance is created or updated (i.e. the user went,
// through the Filter Edit Control dialogue) this is call is issued to
// the filter. The filter may use it to create/update its node controls.
//
// See example in negative.cpp.
dVirtual void FilterUpdate ( ) { }
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-- Main Filter Manager Class
//
//
class FilterManager {
TCHAR name[MAXFILTERNAME];
FLTInterface *iface;
ImageFilterInfo *ifi;
Interface *max;
//-- General Private Methods
BOOL SetupPlugIn ( HWND hWnd, WORD item );
void HandleMaskFile ( HWND hWnd, WORD item );
//-- Image Filter Private Methods
int GetCurrentFilter ( HWND hWnd, TCHAR *plugin );
void HandleFilterDialogState ( HWND hWnd );
public:
FLTExport FilterManager ( FLTInterface *i);
FLTExport FilterManager ( FLTInterface *i,const TCHAR *name);
FLTExport ~FilterManager ( );
FLTExport FLTInterface *iFace ( ) { return iface;}
void DoConstruct ( FLTInterface *i,const TCHAR *name);
FLT_FilterList fltList;
FLTExport void ListFilters ( );
FLTExport HINSTANCE AppInst ( );
FLTExport HWND AppWnd ( );
FLTExport DllDir *AppDllDir ( );
FLTExport Interface *Max ( ) { return max; }
//-- User Interface -------------------------------
BOOL ImageFilterControl ( HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam );
//-- This function will create a mask bitmap based
// on the given ImageFilterInfo class.
Bitmap *ProcessMask ( HWND hWnd, ImageFilterInfo *ii );
//-- This function will list all available filter
// plug-ins. The "item" argument defines an id
// for a combo box to receive the list whithin
// the hWnd context. It returns the number of
// filters found.
FLTExport int GetFilterList ( HWND hWnd, int item );
FLTExport int GetLayerList ( HWND hWnd, int item );
//-- This runs the show. Thew window handle is used
// to send progress messages back. See above the
// discussion about messages. The host should
// check keyboard and cancel buttons and return
// FALSE to a FLT_PROGRESS or FLT_CHECKABORT
// message telling the Plug-In to cancel.
FLTExport BOOL RenderFilter ( HWND hWnd,
ImageFilterInfo *ii,
Bitmap *map,
Bitmap *foreMap = NULL);
//-- This will bring a full blown dialog giving the
// user an interface to select and define a plug-
// in filter. Returns FALSE if the user cancels.
FLTExport BOOL SelectImageFilter( HWND hWnd, ImageFilterInfo *ii );
//-- This will fill out the given combo box with a
// list of available mask options
FLTExport void ListMaskOptions ( HWND hWnd, int item);
//----------------------------------------------------------------------
//-- R2 Stuff Below ----------------------------------------------------
//----------------------------------------------------------------------
//-- Internal Use
FLTExport void UpdateFilter ( ImageFilterInfo *ii );
};
//-----------------------------------------------------------------------------
//-- Forward References
//
extern FLTExport void OpenFLT ( FLTInterface *i );
extern FLTExport void CloseFLT ( );
//-----------------------------------------------------------------------------
//-- The Primary Filter Manager Object
//
// TO DO: Move to App data structure?
extern FLTExport FilterManager *TheFilterManager;
#endif
//-- EOF: filters.h -----------------------------------------------------------