source: golgotha/src/maxtool/sdk_inc/filters.h @ 80

Last change on this file since 80 was 80, checked in by Sam Hocevar, 12 years ago
  • Adding the Golgotha source code. Not sure what's going to be interesting in there, but since it's all public domain, there's certainly stuff to pick up.
  • Property svn:keywords set to Id
File size: 20.9 KB
Line 
1//-----------------------------------------------------------------------------
2// --------------------
3// File ....:   Filters.h
4// --------------------
5// Author...:   Gus Grubba
6// Date ....:   September 1995
7//
8// History      .:      Sep, 07 1995 -  Started
9//
10//-----------------------------------------------------------------------------
11               
12#ifndef FILTERS_H_DEFINED
13#define FILTERS_H_DEFINED
14
15#include "fltapi.h"
16
17//--    Just to make it shorter
18
19#define dVirtual        FLTExport virtual
20
21//--    How long        can a   filter name     be
22
23#define MAXFILTERNAME MAX_PATH
24#define MAXRESOURCE       MAX_PATH
25
26//-----------------------------------------------------------------------------
27//-----------------------------------------------------------------------------
28//--    Frame   Range
29//
30       
31class FrameRange        {
32
33                int start;
34                int end;
35                int current;
36               
37         public:
38         
39                FLTExport                 FrameRange    ( ) {start = end = current      = 0;}
40                FLTExport                ~FrameRange    ( ) {};
41
42                FLTExport int     First                 ( ) {   return (start); }
43                FLTExport int     Last                  ( ) {   return (end); }
44                FLTExport int     Count                 ( ) {   return (end     - start + 1); }
45                FLTExport int     Current               ( ) {   return (current);       }
46                FLTExport int     Elapsed               ( ) {   return (current -       start); }
47
48                FLTExport void    SetFirst              ( int   u ) {   start     = u; }
49                FLTExport void    SetLast               ( int   u ) {   end       = u; }
50                FLTExport void    SetCurrent    ( int   u ) {   current = u; }
51
52
53};
54
55//-----------------------------------------------------------------------------
56//-----------------------------------------------------------------------------
57//--    Forward Reference
58
59class ImageFilter;
60class FilterManager;
61
62//-----------------------------------------------------------------------------
63//-----------------------------------------------------------------------------
64//--    Filter Info
65//
66       
67enum    MaskType        {
68        MASK_R =        0,     
69        MASK_G,
70        MASK_B,
71        MASK_A,
72        MASK_L,
73        MASK_Z,
74        MASK_MTL_ID,
75        MASK_NODE_ID
76
77};
78
79#define NUMMASKFLAGS (MASK_NODE_ID      - MASK_R) +     1
80
81class ImageFilterInfo {
82
83                //-- To Add     -------------------------------------------------
84                //
85                //      Render to Fields
86                //      Camera/View     data
87                //     
88               
89               
90               
91                //-- Name of the filter used internally for identitification.
92
93                TCHAR                                                    name[MAXFILTERNAME];
94
95                //-- Filters may want to identify themselves    by      something more 
96                //        specific than their names. Specially  filters that give       names
97                //        to parameter  sets.   If      "resource" below is not empty, it
98                //        will be used  to      identify        the filter in the       Video   Post Queue.
99                //        This is saved along with      everything else by the host (Max).
100                //        If all        the filter needs is a resource to identify a    set of
101                //        parameters, this will sufice.
102
103                TCHAR                                                    resource[MAXRESOURCE];
104
105                //-- Plug-In Parameter Block ------------------------------------------
106                //
107                //        No direct     access to clients. Use the      methods in the  filter class.
108                //
109
110                void                                                    *pidata;
111                DWORD                                                    pisize;
112
113        public:
114
115                FLTExport                                        ImageFilterInfo                                  ( );
116                FLTExport                                       ~ImageFilterInfo                                  ( );
117
118                //-- Mask Information -------------------------------------------------
119
120                BOOL                                                     maskenabled;
121                BOOL                                                     invertedmask;
122                BitmapInfo                                       mask;
123                WORD                                                     maskflag;
124
125                //-- This is a BitmapInfo that holds information about the current
126                //   Video Post main queue Image buffer. This can be used to get
127                //   VP's (or target image) resolution, etc. To make an analogy, if
128                //   this was a BitmapIO plug-in, this is the BitmapInfo given as
129                //   the argument. This used primarilly at the time the filter
130                //   receives the "Setup()" call as at render time, all this can be
131                //   found in srcmap.
132
133                BitmapInfo                                       imgQueue;
134
135                //-- Internal Helpers -------------------------------------------------
136
137                FLTExport void                           SetName                                                          ( const TCHAR *n )    { _tcscpy(name,n);}
138                FLTExport void                           SetResource                                      ( const TCHAR *n )    { _tcscpy(resource,n);}
139                FLTExport const TCHAR   *Name                                                             ( )   { return        (const TCHAR *)name;}
140                FLTExport const TCHAR   *Resource                                                 ( )   { return        (const TCHAR *)resource;}
141               
142                //-- Plug-In Parameter Block ------------------------------------------
143               
144                FLTExport void                          *GetPiData                                                ( )   { return        pidata;                   }
145                FLTExport void                           SetPiData                                                ( void        *ptr ) {        pidata =        ptr; }
146                FLTExport DWORD                  GetPiDataSize                                    ( )   { return        pisize;                   }
147                FLTExport void                           SetPiDataSize                                    ( DWORD s     ) { pisize = s;   }
148                FLTExport void                           ResetPiData                                      ( );
149                FLTExport BOOL                           AllocPiData                                      ( DWORD size  );
150
151                FLTExport ImageFilterInfo &operator= (  ImageFilterInfo &from );
152               
153                //-- Load/Save
154               
155                FLTExport IOResult               Save                                                             ( ISave *isave );
156                FLTExport IOResult               Load                                                             ( ILoad *iload );
157               
158                //-- Execution  Info ---------------------------------------------------
159                //
160                //        12/06/95 - GG
161                //
162                //        QueueRange defines    the entire Video Post Queue range. Execution
163                //        is only the portion being rendered. This is, unless   the user        selects
164                //        a "range", the same as QueueRange. FilterRange is where this  filter
165                //        starts        and ends.
166                //
167                //        Video Post Queue
168                //
169                //                                      1                        2                        3                     4                        5
170                //        0----|----|----|----|----|----|----|----|----|----|----|----|----|---- ...
171                //
172                //        Video Post spans from 0 to 49 (QueueRange)    Start: 0         End:   49
173                //
174                //        qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
175                //
176                //        User executes a       "range" from 10 to 30 (Execution        Range) Start: 10 End: 30
177                //
178                //                                      uuuuuuuuuuuuuuuuuuuuu
179                //
180                //        This filter appears in the queue from 5       to      35      (Filter Range)  Start: 5        End: 35
181                //
182                //                       fffffffffffffffffffffffffffffff               
183
184                FrameRange                                       QueueRange;                      //-- Entire Video Post Queue
185                FrameRange                                       ExecutionRange;                  //-- Segement being rendered
186                FrameRange                                       FilterRange;                     //-- Filter Segment
187               
188
189};
190
191//-----------------------------------------------------------------------------
192//-----------------------------------------------------------------------------
193//--    Filter Plug-Ins Handler
194//
195       
196class FLT_FilterHandler {
197
198                //-- Name and Capabilities      ------------------------
199               
200                TCHAR             fltDescription[MAXFILTERNAME];       
201                DWORD             fltCapability;
202
203                //-- DLL        Handler ----------------------------------
204               
205                ClassDesc *cd;
206               
207        public:
208
209                FLT_FilterHandler();
210               
211                FLTExport TCHAR                   *Description            ( const TCHAR  *d = NULL      );
212
213                FLTExport void                                  SetCD                             ( ClassDesc *dll )    { cd = dll;}
214                FLTExport ClassDesc               *GetCD                                  ( )                                           { return        cd;}
215
216                FLTExport void                                  SetCapabilities  ( DWORD cap )          { fltCapability |= cap;}
217                FLTExport DWORD                         GetCapabilities  ( )                                            { return        (fltCapability);}
218                FLTExport BOOL                                  TestCapabilities ( DWORD cap )          { return        (fltCapability  & cap);}
219
220};
221
222//-----------------------------------------------------------------------------
223//-----------------------------------------------------------------------------
224//--    List of Filter  Plug-Ins
225//
226       
227class FLT_FilterList: public    Tab<FLT_FilterHandler> {
228
229                BOOL            listed;
230                 
231        public:
232
233                FLT_FilterList            ( )                                           { listed        = FALSE;        }
234
235                BOOL            Listed    ( BOOL        f)                              { listed        = f; return     (listed);};
236                BOOL            Listed    ( )                                           { return        (listed);};
237
238                FLTExport int    FindFilter                                     ( const TCHAR *name );
239                FLTExport DWORD GetFilterCapabilities   ( const TCHAR *name );
240
241                //-- This Creates       an      Instance        - Make sure     to      "delete"        it      after   use.
242
243                FLTExport ImageFilter *CreateFilterInstance(const TCHAR *d);
244
245};
246
247//-----------------------------------------------------------------------------
248//-----------------------------------------------------------------------------
249//--    ImageFilter     Capability Flags
250//
251//      It      is      valid   for a   plug-in to both Filter and      Compositor.     If      both flags are
252//      set, the        user will be able       to      select it from  both the        Filter list     and from
253//      the Compositor  list.   The plug-in     will know it is running as      a filter        when
254//      the foreground  map pointer     is      NULL.
255//
256
257#define IMGFLT_NONE                                      0                      //      None
258
259#define IMGFLT_MASK                                      (1<<0) //      Supports Masking
260#define IMGFLT_CONTROL                           (1<<1) //      Plug-In has     a Control Panel
261#define IMGFLT_FILTER                            (1<<2) //      Plug-In is a Filter
262#define IMGFLT_COMPOSITOR                        (1<<3) //      Plug-In is a Compositor
263#define IMGFLT_THREADED                  (1<<4) //      Thread aware plug-in
264
265//--    Class   ID's for        various DLL's
266
267#define NEGATIVECLASSID 0x4655434A
268#define ALPHACLASSID            0x655434A4
269#define ADDCLASSID                      0x55434A46
270#define BLURCLASSID                     0x5434A465
271#define CROSFADECLASSID 0x434A4655
272#define GLOWCLASSID                     0x35A46554
273#define COOKIECLASSID           0x4A465543
274#define WIPECLASSID                     0xA4655434
275#define FADECLASSID                     0x4655434B
276#define PDALPHACLASSID          0x655434B4
277
278//-----------------------------------------------------------------------------
279//-----------------------------------------------------------------------------
280//--    Image   Filter Class
281//
282
283class ImageFilter {
284       
285        protected:
286
287                //-- Bitmap     Pointers        --------------------------------------------------
288                //
289                //        All   filters will have       at      least   a pointer to "srcmap". This is VP's
290                //        (or   any other process') main image pipeline.
291                //
292                //        Composition filters will      also receive a  second [frgmap] bitmap
293                //        which should  be      composited above the    main [srcmap] bitmap.
294                //
295                //        If "mskmap" is not    NULL,   it      will contain a  pointer to a grayscale
296                //        image to be used as a mask for        the process.
297                //
298                //        12/06/95 - GG
299                //
300                //        The   srcmap (Background) is the      Video   Post queue bitmap. Use its
301                //        methods to find       out dimmensions (width, height, aspect  ratio, etc.)
302                //        If the        queue   is      using   Alpha   channel,        it      will be noted in the    bitmap
303                //        flags (srcmap).       The same        is      true for        Z and   G buffers. Again,       simply
304                //        use   the bitmap methods to access these.
305                //
306               
307                Bitmap                                          *srcmap;                 //--   Source (Background)
308                Bitmap                                          *mskmap;                 //--   Mask (Grayscale Masking)
309                Bitmap                                          *frgmap;                 //--   Foreground (for layering/transitions)
310               
311                //-- Set        by      Host ----------------------------------
312               
313                ImageFilterInfo                 *ifi;
314               
315        public:
316       
317                FLTExport       ImageFilter             ( ) {
318                                srcmap =        NULL;   
319                                mskmap =        NULL;
320                                frgmap =        NULL;
321                }
322                                                                                                                                                                         
323                dVirtual                                                ~ImageFilter                                    ( ) {}
324               
325                //-- Filter     Info    ---------------------------------
326               
327                dVirtual         const TCHAR    *Description                                    ( ) = 0; // ASCII description (i.e. "Convolution        Filter")
328                dVirtual         const TCHAR    *AuthorName                                             ( ) = 0; // ASCII Author        name
329                dVirtual         const TCHAR    *CopyrightMessage                               ( ) = 0; // ASCII Copyright     message
330                dVirtual         UINT                            Version                                                        ( ) = 0; // Version number * 100 (i.e. v3.01 = 301)
331                dVirtual         DWORD                   Capability                                             ( ) = 0; // Returns capability  flags   (see above)
332
333                //-- Dialogs ----------------------------------------------------------
334                //
335                //        An About Box  is      mandatory. The  Control panel is optional and   its
336                //        existence     should be flagged       by      the Capability  flag above.
337                //
338
339                dVirtual         void                            ShowAbout                                                ( HWND        hWnd ) =        0;
340                dVirtual         BOOL                            ShowControl                                      ( HWND        hWnd ) {        return FALSE; }
341
342                //-- Parameter  Setting (Host's Responsability) ----
343
344                dVirtual         void                            SetSource                                                ( Bitmap *map )         {srcmap =     map;}
345                dVirtual         void                            SetForeground                                    ( Bitmap *map )         {frgmap =     map;}
346                dVirtual         void                            SetMask                                                          ( Bitmap *map )         {mskmap =     map;}
347                dVirtual         void                            SetFilterInfo                                    ( ImageFilterInfo *i ) {ifi   = i;}
348
349                //-- Execution  ------------------------------------
350                //
351                //        The   "hWnd" argument is a    window handler  to      which
352                //        the   plug-in will be sending messages.
353
354                dVirtual         BOOL                            Render                                                   ( HWND        hWnd ) =        0;
355
356                //-- Max        Interface ----------------------------------------------------
357                //
358                //        Some of Max's core    functions exported through      the Interface class.
359                //
360
361                dVirtual        Interface               *Max                                                              ( );
362
363                //-- Helpers --------------------------------------
364
365                dVirtual        int                             Lerp                                                              (int a, int b, int l);
366                dVirtual        int                             Lerp                                                              (int a, int b, float f);
367               
368                //-- Parameter  Block   Load and        Save ------------------------------------
369                //
370                //       The host will  call EvaluateConfigure() to determine the       buffer size
371                //       required by the plug-in.
372                //
373                //       SaveConfigure() will be called so the  plug-in can     transfer        its
374                //       parameter block to the host ( ptr is a pre-allocated   buffer).
375                //
376                //       LoadConfigure() will be called so the  plug-in can     load its       
377                //       parameter block back.
378                //       
379                //       Memory management is performed by the  host using standard
380                //       LocalAlloc() and       LocalFree().
381                //       
382               
383                dVirtual         DWORD                   EvaluateConfigure                        ( )                            {      return 0; }
384                dVirtual         BOOL                            LoadConfigure                                    ( void        *ptr ) {        return (FALSE); }
385                dVirtual         BOOL                            SaveConfigure                                    ( void        *ptr ) {        return (FALSE); }
386
387                //-- Preview Facility -------------------------------------------------
388                //
389                //        This is used  by      plug-ins        that want to have       a preview bitmap while
390                //        displaying its control dialogue.
391                //
392                //        The   flag controls how       much of the     queue   to      run:
393                //
394                //        PREVIEW_BEFORE - The queue is run     up      to      the event before the    filter
395                //        calling it.
396                //
397                //        PREVIEW_UP ----- The queue is run     up      to      the event (filter) calling
398                //        this function.
399                //
400                //        PREVIEW_WHOLE -- The whole queue is run       including events after
401                //        this filter.
402                //
403                //        The   given   frame   is      the Video Post  Queue   frame   number and not  Max's
404                //        frame number.
405                //
406                //
407                //        Parameters:
408                //
409                //        hWnd -        WIndow handle to send messages to. These are    the progress,
410                //        check for     abort, text     messages        etc. If the     plug in wants to support
411                //        a cancel button       and progress bars       etc, it must handle these messages.
412                //        It is Ok to send a    NULL window     handle in which case    nothing is checked.
413                //
414                //        back -        Pointer to a Bitmap pointer. If the     Bitmap pointer  is      NULL,   a
415                //        new   bitmap is created       using   the given dimmensions. This pointer     must be
416                //        NULL the first time this      function        is      called as the bitmap    must be
417                //        created by Video Post. Once   this function is called and a   bitmap is
418                //        returned,     it      is      ok      to      call it again using this map.   In      this case, Video
419                //        Post will     simply use it instead of creating a     new one.        You must        delete
420                //        the   bitmap when     done.
421                //
422                //        fore -        For layer plug-ins, this points to the  foreground image.       This is
423                //        only valid if flag    is      set to PREVIEW_BEFORE. In this case     back will hold 
424                //        Video Post main       queue   and fore        will have the foreground image to be
425                //        composited. This is usefull   if      you, a layer plug-in, want      to      collect the     
426                //        images        and run a real  time preview. If flag is not PREVIEW_BEFORE,    fore
427                //        will be a     NULL pointer indicating there   is      no      bitmap.
428                //
429                //        frame - The desired frame. Make sure  you request     a frame within  the
430                //        range your plug-in    is      active.
431                //
432                //        width & height - Self explanatory.
433                //
434                //        flag -        Explained above.
435                //
436
437                #ifndef PREVIEW_BEFORE
438                #define PREVIEW_BEFORE  1
439                #define PREVIEW_UP              2
440                #define PREVIEW_WHOLE   3
441                #endif
442
443                dVirtual        BOOL CreatePreview  (
444                                HWND hWnd,                                              //-- Window     handle to send  messages        to
445                                Bitmap **back,                                  //-- Pointer to Bitmap Pointer (Background)
446                                int frame,                                              //-- Desired Frame
447                                int width,                                              //-- Desired Width
448                                int height,                                             //-- Desired Height
449                                float   aspect,                                 //-- Desired Aspect Ratio
450                                Bitmap **fore   = NULL,         //-- Pointer to Bitmap Pointer (Foreground)
451                                DWORD   flag            = PREVIEW_UP );
452
453                //---------------------------------------------------------------------
454                //-- Channels Required
455                //
456                //        By setting this       flag,   the plug-in     can request     the host        to      generate
457                //        the   given   channels. Prior to Rendering,   the host        will scan the
458                //        plug-ins in the       chain   of      events and list all types of channels
459                //        being requested. The plug-in, at the  time of the     Render()        call,   
460                //        will have     access to these channels through        the channel     interface
461                //        described     in      Bitmap.h        - BitmapStorage.
462                //
463                //        The   generation of these channels should     not, normally,  be      a
464                //        default setting       for a   plug-in.        These   channels        are memory hungry       and
465                //        if the        plug-in won't use       it, it should not       ask for it.     Normally
466                //        the   plug-in would ask       the user        which   channels        to      use and set     only
467                //        the   proper flags.
468                //
469               
470                dVirtual         DWORD   ChannelsRequired               ( ) {   return BMM_CHAN_NONE; }
471               
472};
473
474//-----------------------------------------------------------------------------
475//--    Messages        sent back by various    (client)        methods
476
477//--    Sent by the     plug-in to notify       host of current progress. The   host should
478//      return TRUE     if      it's ok to continue or FALSE to abort process.
479
480#define FLT_PROGRESS    WM_USER + 0x20    //-- wParam:  Current lParam: Total
481
482//--    Sent by the     plug-in to check for    process interruption. The host should
483//      return FALSE (by setting *lParam) if it's       ok      to      continue        or      TRUE to abort
484//      process.
485
486#define FLT_CHECKABORT  WM_USER + 0x21    //-- wParam:  0                 lParam: BOOL*
487
488//--    Sent by the     plug-in to display an optional textual  message (for progress
489//      report).
490
491#define FLT_TEXTMSG             WM_USER + 0x22    //-- wParam:  0                 lParam: LPCTSTR
492
493//-----------------------------------------------------------------------------
494//-----------------------------------------------------------------------------
495//--    Main Filter     Manager Class
496//
497//
498
499class FilterManager     {
500       
501                TCHAR                                                   name[MAXFILTERNAME];
502                FLTInterface                            *iface;
503                ImageFilterInfo                 *ifi;
504                Interface                                       *max;
505
506                //-- General Private    Methods
507               
508                BOOL                                                    SetupPlugIn                                             ( HWND hWnd, WORD       item );
509                void                                                    HandleMaskFile                                  ( HWND hWnd, WORD       item );
510               
511                //-- Image Filter       Private Methods
512               
513                int                                                     GetCurrentFilter                                ( HWND hWnd, TCHAR *plugin      );
514                void                                                    HandleFilterDialogState         ( HWND hWnd     );
515
516        public:
517       
518                FLTExport                                       FilterManager                                   ( FLTInterface  *i);
519                FLTExport                                       FilterManager                                   ( FLTInterface  *i,const        TCHAR   *name);
520                FLTExport                                       ~FilterManager                                  ( );
521               
522                FLTExport FLTInterface  *iFace                                                  ( ) {   return iface;}
523               
524                void                                                    DoConstruct                                             ( FLTInterface  *i,const        TCHAR   *name);
525               
526                FLT_FilterList                          fltList;
527                FLTExport void                          ListFilters                                             ( );
528               
529                FLTExport HINSTANCE             AppInst                                                 ( );
530                FLTExport HWND                          AppWnd                                                  ( );
531                FLTExport DllDir                        *AppDllDir                                              ( );
532                FLTExport Interface             *Max                                                            ( ) {   return max;     }
533               
534                //-- User Interface -------------------------------
535
536                BOOL                                                    ImageFilterControl                      ( HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam );
537               
538                //-- This function will create a        mask bitmap     based
539                //        on the        given   ImageFilterInfo class.
540               
541                Bitmap                                          *ProcessMask                                    ( HWND hWnd, ImageFilterInfo    *ii );
542               
543                //-- This function will list all        available filter
544                //        plug-ins.     The "item" argument defines an id
545                //        for   a combo box     to      receive the     list whithin
546                //        the   hWnd context. It returns the number     of     
547                //        filters found.
548               
549                FLTExport int                           GetFilterList                                   ( HWND hWnd, int item );
550                FLTExport int                           GetLayerList                                    ( HWND hWnd, int item );
551               
552                //-- This runs  the show. Thew  window handle is used
553                //        to send progress messages back. See above the
554                //        discussion about messages. The        host should
555                //        check keyboard and    cancel buttons  and return
556                //        FALSE to a FLT_PROGRESS or FLT_CHECKABORT
557                //        message telling       the Plug-In     to      cancel.
558               
559                FLTExport BOOL                          RenderFilter                                    ( HWND hWnd,
560                                                                                                                                                          ImageFilterInfo       *ii,
561                                                                                                                                                          Bitmap        *map,
562                                                                                                                                                          Bitmap        *foreMap        = NULL);
563               
564                //-- This will  bring   a full blown dialog giving      the
565                //        user an interface to select   and define a plug-
566                //        in filter. Returns    FALSE   if      the user        cancels.
567               
568                FLTExport BOOL                          SelectImageFilter                               ( HWND hWnd, ImageFilterInfo *ii        );
569               
570                //-- This will  fill out        the given combo box with a
571                //        list of available mask options
572               
573                FLTExport void                          ListMaskOptions                         ( HWND hWnd, int item);
574};
575
576//-----------------------------------------------------------------------------
577//--    Forward References
578//
579
580extern FLTExport        void                     OpenFLT                                                         (      FLTInterface *i );
581extern FLTExport        void                     CloseFLT                                                (      );
582
583//-----------------------------------------------------------------------------
584//--    The Primary     Filter Manager  Object
585//
586//      TO      DO: Move        to      App data        structure?
587
588extern  FLTExport FilterManager *TheFilterManager;
589
590#endif
591
592//--    EOF: filters.h  -----------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.