maxnet_job.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// -----------------------
// File ....: maxnet_job.h
// -----------------------
// Author...: Gus J Grubba
// Date ....: March 2000
// O.S. ....: Windows 2000
//
// History .: March, 11 2000 - Created
//
// 3D Studio Max Network Rendering Classes - Job
// 
//-----------------------------------------------------------------------------

#pragma once
#include <WTypes.h>
#include "strbasic.h"
#include "maxheap.h"
#include "network\MaxNetExport.h"
#include "maxnet_types.h"

// forward declarations
class MaxNetManagerImp;


//-----------------------------------------------------------------------------
//-- Scene Info

//#define SCENE_SHADOWMAPPED    (1<<0)  Obsolete
//#define SCENE_RAYTRACED       (1<<1)  Obsolete
#define SCENE_VIDEOCOLORCHECK   (1<<2)
#define SCENE_TWOSIDED          (1<<3)
#define SCENE_RENDERHIDEN       (1<<4)
#define SCENE_RENDERATMOSPHER   (1<<5)
#define SCENE_SUPERBLACK        (1<<6)
//#define SCENE_RENDERALPHA     (1<<7)  Obsolete
#define SCENE_SERIALNUMBERING   (1<<8)
#define SCENE_DITHER256         (1<<9)
#define SCENE_DITHERTRUE        (1<<10)
#define SCENE_RENDERFIELDS      (1<<11)
#define SCENE_DISPLACEMENT      (1<<12)
#define SCENE_EFFECTS           (1<<13)
#define SCENE_FIELDORDER        (1<<14)     //-- 0 Even / 1 Odd

struct SceneInfo: public MaxHeapOperators {
    int     objects;
    int     faces;
    int     lights;
    int     start,end;
    DWORD   flags;
};

//-----------------------------------------------------------------------------
//-- Text Info
//

enum JOB_TEXT_TYPE
{
    JOB_TEXT_USER = 64,             
    JOB_TEXT_COMPUTER,              
    JOB_TEXT_MANAGER_SHARE,         
    JOB_TEXT_FRAMES,                
    JOB_TEXT_MAX_OUTPUT,            
    JOB_TEXT_CMB_OUTPUT,            
    JOB_TEXT_RENDER_ELEMENT,        
    JOB_TEXT_CAMERA,                
    JOB_TEXT_RENDER_SCENE_STATE,    
    JOB_TEXT_SCENE_STATES,          
    JOB_TEXT_BATCH_RENDER,          
    JOB_TEXT_PRE_REND_SCRIPT,       
    JOB_TEXT_POST_REND_SCRIPT,      
    JOB_TEXT_RESERVED = 9999        
};

struct TextBufferOutput: public MaxHeapOperators {
    bool    device;
    float   gamma;
    MCHAR   data[256];
};

struct JobRenderElement: public MaxHeapOperators {
    bool    enabled;
    bool    filterenabled;
    bool    atmosphere_applied;
    bool    shadows_applied;
    MCHAR   name[128];
    MCHAR   output[MAX_PATH];
};

struct JobText: public MaxHeapOperators {
    JOB_TEXT_TYPE type;
    union {
        MCHAR           text[256];
        TextBufferOutput    output;
        JobRenderElement    re;
    };
};

class MAXNETEXPORT CJobText: public MaxHeapOperators {
    friend class MaxNetManagerImp;
    protected:
        void*   list;
    public:
                CJobText        ( );
                ~CJobText       ( );
        
        int         Count       ( );
        int         Add         (JobText* jt);
        void        Delete      (int idx, int count = 1);
        void        Reset       ( );
        JobText*    Buffer      ( );
        int         BufferSize  ( );
        
        JobText& operator[](const int i);

        int     FindJobText     (JOB_TEXT_TYPE tp, int start = 0);
        bool    GetTextItem     (MCHAR* text, JOB_TEXT_TYPE type, int start = 0, int* idx = 0);
        bool    GetUser         (MCHAR* user);
        bool    GetComputer     (MCHAR* computer);
        bool    GetFrames       (MCHAR* frames);
        bool    GetShare        (MCHAR* share);

};

//---------------------------------------------------------
//-- Alert Notification
//

#define NOTIFY_FAILURE      (1<<0)
#define NOTIFY_PROGRESS     (1<<1)
#define NOTIFY_COMPLETION   (1<<2)

struct AlertData: public MaxHeapOperators {
    bool        alertEnabled;
    DWORD       notifications;
    int     nthFrames;              
};

//---------------------------------------------------------
//-- Job Flags

#define JOB_VP              (1<<0)      //!< Video Post (otherwise is Render Scene)
#define JOB_NONC            (1<<1)      //!< Non concurrent driver (Accom, AVI, etc.)
#define JOB_MAPS            (1<<2)      //!< Include Maps
#define JOB_NONSTOP         (1<<3)      //!< Uninterruptible Driver (AVI, FCL, etc.)
#define JOB_SKIPEXST        (1<<4)      //!< Skip Existing Frames
#define JOB_ALLSERVERS      (1<<5)      //!< Use All Available Servers
#define JOB_INACTIVE        (1<<6)      //!< Job is Suspended
#define JOB_COMPLETE        (1<<7)      //!< Job is Complete (Read Only)
#define JOB_IGNORESHARE     (1<<8)      //!< Ignore Manager's Job Share - Always request archives
#define JOB_SKIPOUTPUTTST   (1<<9)      //!< Skip output test (Server won't test the output path)
#define JOB_NONSEQFRAMES    (1<<10)     //!< Non sequential frames (1,3,5-10, etc.)
#define JOB_COMBUSTIONJOB   (1<<11)     //!< Combustion Job
#define JOB_NOTARCHIVED     (1<<12)     //!< Uncompressed File (not an archive)
#define JOB_VFB             (1<<13)     //!< Should the VFB be up?
#define JOB_RENDER_CROP     (1<<14)     //!< Partial Render (Crop / Zoom / Region / etc.)

#define JOB_ASSIGN_VP       JOB_VP      //-- Make compatible with legacy flag
#define JOB_ASSIGN_RND      0           //-- Make compatible with legacy flag

//---------------------------------------------------------
//-- Priority Level

#define _JOB_PRIORITY_CRITICAL  0
#define _JOB_DEFAULT_PRIORITY   50

//---------------------------------------------------------
//-- Job

#define _JOB_VERSION 399

struct MaxJobRenderElements: public MaxHeapOperators {
    bool        enabled;
};

struct MaxJob: public MaxHeapOperators {
    bool        init;               //-- Is structure valid?
    bool        gammacorrection;        //-- Use gamma correction?
    float       gammavaluein;           //-- Input Gamma (Maps)
    float       gammavalueout;          //-- Output Gamma (Output Image)
    float       pixelaspect;            //-- Pixel Aspect Ratio
    char        camera[128];            //-- Camera
    SceneInfo   sceneInfo;          //-- Scene Info
    MaxJobRenderElements    re;         //-- Render Elements
    char        reserved[64];
};

struct CombustionJob: public MaxHeapOperators {
    bool        init;
    char        reserved[128];
};

struct Job: public MaxHeapOperators {
    DWORD       size;
    DWORD       version;
    DWORD       server_pid;
    DWORD       flags;
    HJOB        hJob;
    char        name[MAX_PATH];
    DWORD       filesize;           

    DWORD       filesizeextracted;      

    SYSTEMTIME  submission;
    SYSTEMTIME  startjob;
    SYSTEMTIME  endjob;
    int     servercount;
    AlertData   alerts;
    int     jobtextcount;
    int     firstframe;
    int     lastframe;
    int     step;
    int     width,height;
    int     frames_completed;
    char        priority;
    char        reserved[32];
    union {
        MaxJob          maxJob;         //-- MAX Specific
        CombustionJob   combustionJob;  //-- Combustion Specific
    };
};