/**********************************************************************

 *<

	FILE: render.h



	DESCRIPTION:



	CREATED BY: Dan Silva



	HISTORY:



 *>	Copyright (c) 1994, All Rights Reserved.

 **********************************************************************/





#ifndef __RENDER__H

#define __RENDER__H



#define FIELD_EVEN 0

#define FIELD_ODD 1



// Render Types   RB: I didn't want to include render.h in MAXAPI.H...

#ifndef _REND_TYPE_DEFINED

#define _REND_TYPE_DEFINED

enum RendType { 

	RENDTYPE_NORMAL,

	RENDTYPE_REGION,

	RENDTYPE_BLOWUP,

	RENDTYPE_SELECT

	};

#endif



#define PROJ_PERSPECTIVE 0

#define PROJ_PARALLEL 1



class DefaultLight {

	public:

	LightState ls;

	Matrix3 tm;	

	};



class ViewParams {

	public:

		Matrix3 affineTM;

		int projType;  // PROJ_PERSPECTIVE or PROJ_PARALLEL

		float hither,yon;

		// Parallel projection params

		float zoom;  // Zoom factor 

		// Perspective params

		float fov; 	// field of view

	};





// Common renderer parameters



class Atmospheric;



// These parameters are passed to the renderer when the renderer is opend.

class RendParams {

	public:

	RendType rendType;	

	// boundaries of the region for render region or render blowup

	// in device coords.

	int regxmin,regxmax;

	int regymin,regymax;



#if 0 // RB: These come from the bitmap now.

	int width, height;

	float aspect;

#endif

	BOOL isNetRender;  // is this a render on a network slave?	

	BOOL fieldRender;

	int fieldOrder;    // 0->even, 1-> odd

	TimeValue frameDur; // duration of one frame

	

	BOOL colorCheck;

	int vidCorrectMethod; // 0->FLAG, 1->SCALE_LUMA 2->SCALE_SAT

	int ntscPAL;  // 0 ->NTSC,  1 ->PAL

	BOOL superBlack;

	int sbThresh;

	BOOL rendHidden;

	BOOL force2Side;

	BOOL inMtlEdit;	  // rendering in the mtl editor?

	float mtlEditTile; // if so, scale tiling

	BOOL mtlEditAA;   // if so, antialias? 

	BOOL multiThread; // for testing only

	BOOL useEnvironAlpha;  // use alpha from the environment map.

	BOOL dontAntialiasBG; // Don't antialias against background (for video games)		

	Texmap *envMap;		// The environment map, may be NULL

	Atmospheric *atmos; // The atmosphere effects, may be NULL.

	RendParams() { inMtlEdit=0; mtlEditAA = 0; }

	};						   



// These are passed to the renderer on every frame

class FrameRendParams {

	public:

	Color ambient;

	Color background;

	float frameDuration; // duration of one frame, in current frames

	FrameRendParams() { frameDuration = 1.0f; }

	};



// Since this dialog is modless and non-interactive, as the user changes

// parameters in the dialog, the renderer does not need to update it's

// state. When the user is through, they may choose 'OK' or 'Cancel'.

//

// If the user OKs the dialog, AcceptParams() will be called, at which time the

// renderer can read the parameter out of the UI and modify its state.

// 

// If RejectParams() is called, typically the renderer will not have to do anything

// since it has not yet modify its state, but if for some reason it has, it

// should restore its state.

class RendParamDlg {

	public:

		virtual void AcceptParams()=0;

		virtual void RejectParams() {}

		virtual void DeleteThis()=0;		

	};



// Flag bits for DoMaterialBrowseDlg()

#define BROWSE_MATSONLY		(1<<0)

#define BROWSE_MAPSONLY		(1<<1)

#define BROWSE_INCNONE		(1<<2) 	// Include 'None' as an option

#define BROWSE_INSTANCEONLY	(1<<3) 	// Only allow instances, no copy



// passed to SetPickMode. This is a callback that gets called as

// the user tries to pick objects in the scene.

class RendPickProc {

	public:

		// Called when the user picks something.

		// return TRUE to end the pick mode.

		virtual BOOL Pick(INode *node)=0;



		// Return TRUE if this is an acceptable hit, FALSE otherwise.

		virtual BOOL Filter(INode *node)=0;



		// These are called as the mode is entered and exited

		virtual void EnterMode() {}

		virtual void ExitMode() {}



		// Provides two cursor, 1 when over a pickable object and 1 when not.

		virtual HCURSOR GetDefCursor() {return NULL;}

		virtual HCURSOR GetHitCursor() {return NULL;}

	};





// This is the interface given to a renderer when it needs to display its parameters

// It is also given to atmospheric effects to display thier parameters.

class IRendParams {

	public:

		// The current position of the frame slider

		virtual TimeValue GetTime()=0;



		// Register a callback object that will get called every time the

		// user changes the frame slider.

		virtual void RegisterTimeChangeCallback(TimeChangeCallback *tc)=0;

		virtual void UnRegisterTimeChangeCallback(TimeChangeCallback *tc)=0;



		// Brings up the material browse dialog allowing the user to select a material.

		// newMat will be set to TRUE if the material is new OR cloned.

		// Cancel will be set to TRUE if the user cancels the dialog.

		// The material returned will be NULL if the user selects 'None'

		virtual MtlBase *DoMaterialBrowseDlg(HWND hParent,DWORD flags,BOOL &newMat,BOOL &cancel)=0;



		// Adds rollup pages to the render params dialog. Returns the window

		// handle of the dialog that makes up the page.

		virtual HWND AddRollupPage(HINSTANCE hInst, TCHAR *dlgTemplate, 

			DLGPROC dlgProc, TCHAR *title, LPARAM param=0,DWORD flags=0)=0;



		// Removes a rollup page and destroys it.

		virtual void DeleteRollupPage(HWND hRollup)=0;



		// When the user mouses down in dead area, the plug-in should pass

		// mouse messages to this function which will pass them on to the rollup.

		virtual void RollupMouseMessage(HWND hDlg, UINT message, 

					WPARAM wParam, LPARAM lParam)=0;



		// This will set the command mode to a standard pick mode.

		// The callback implements hit testing and a method that is

		// called when the user actually picks an item.

		virtual void SetPickMode(RendPickProc *proc)=0;

		

		// If a plug-in is finished editing its parameters it should not

		// leave the user in a pick mode. This will flush out any pick modes

		// in the command stack.

		virtual void EndPickMode()=0;

			

		// When a plugin has a Texmap, clicking on the button

		// associated with that map should cause this routine

		// to be called.

		virtual void PutMtlToMtlEditor(MtlBase *mb)=0;



		// This is for use only by the scanline renderer.

		virtual float GetMaxPixelSize() = 0;

	};





// Values returned from Progress()

#define RENDPROG_CONTINUE	1

#define RENDPROG_ABORT		0



// Values passed to SetCurField()

#define FIELD_FIRST		0

#define FIELD_SECOND	1

#define FIELD_NONE		-1



// A callback passed in to the renderer

class RendProgressCallback {

	public:

		virtual void SetTitle(const TCHAR *title)=0;

		virtual int Progress(int done, int total)=0;

		virtual void SetCurField(int which) {}

		virtual void SetSceneStats(int nlights, int nrayTraced, int nshadowed, int nobj, int nfaces) {}

	};





// RB: my version of a renderer...

class Renderer : public ReferenceTarget {

	public:

		// Reference/Animatable methods.

		// In addition, the renderer would need to implement ClassID() and DeleteThis()

		// Since a renderer will probably not itself have references, this implementation should do

		RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 

	         PartID& partID,  RefMessage message) {return REF_SUCCEED;}

		SClass_ID SuperClassID() {return RENDERER_CLASS_ID;}

		

		virtual int Open(

			INode *scene,     	// root node of scene to render

			INode *vnode,     	// view node (camera or light), or NULL

			ViewParams *viewPar,// view params for rendering ortho or user viewport

			RendParams &rp,  	// common renderer parameters

			HWND hwnd, 				// owner window, for messages

			DefaultLight* defaultLights=NULL, // Array of default lights if none in scene

			int numDefLights=0	// number of lights in defaultLights array

			)=0;

						

		//

		// Render a frame -- will use camera or view from open

		//

		virtual int Render(

			TimeValue t,   			// frame to render.

   			Bitmap *tobm, 			// optional target bitmap

			FrameRendParams &frp,	// Time dependent parameters

			HWND hwnd, 				// owner window

			RendProgressCallback *prog=NULL

			)=0;

		virtual void Close(	HWND hwnd )=0;		



		// Adds rollup page(s) to renderer configure dialog

		// If prog==TRUE then the rollup page should just display the parameters

		// so the user has them for reference while rendering, they should not be editable.

		virtual RendParamDlg *CreateParamDialog(IRendParams *ir,BOOL prog=FALSE)=0;

		virtual void ResetParams()=0;





	};





class ShadowBuffer;

class ShadowQuadTree;



class RendContext {

	public:

		virtual ShadowBuffer* NewShadowBuffer() const=0;

		virtual ShadowQuadTree* NewShadowQuadTree() const=0;

		virtual int Progress(int done, int total) const { return 1; }

	};



struct SubRendParams {

	RendType rendType;	

	BOOL fieldRender;

	BOOL evenLines; // when field rendering

	BOOL doingMirror;

	BOOL doEnvMap;  // do environment maps?

	int devWidth, devHeight;

	float devAspect;

	int xorg, yorg;           // location on screen of upper left corner of output bitmap

	int xmin,xmax,ymin,ymax;  // area of screen being rendered

	};



// flags passed to RenderMapsContext::Render()

#define RENDMAP_SHOW_NODE  1  // *Dont* exclude this node from the render.

class RenderMapsContext { 

	public:

	    virtual INode *GetNode()=0;

		virtual int NodeRenderID()=0;

		virtual void GetCurrentViewParams(ViewParams &vp)=0;

		virtual void GetSubRendParams(SubRendParams &srp)=0;

		virtual int SubMtlIndex()=0;

	    virtual void FindMtlPlane(float pl[4])=0;

		virtual void FindMtlScreenBox(Rect &sbox, Matrix3* viewTM=NULL, int mtlIndex=-1)=0;

		virtual	int Render(Bitmap *bm, ViewParams &vp, SubRendParams &srp, float *clipPlane=NULL)=0; 

	};	







// flags passed into ShadowBuffer::Update() and 

// 			ShadowQuadTree::Update()  

#define SHAD_BIAS_ABSOLUTE  1

#define SHAD_PARALLEL  2



//------- A generic Shadow Buffer class for use by lights-------------.

class ShadowBuffer { 

	public:

	virtual int Update(

		const ObjLightDesc& light,

		const RendContext& rendCntxt,

		Matrix3& lightTM,  // lightToWorld

		int size,	// width and height of buffer in pixels

		float aspect, // non-square

		float param,  // persp:field-of-view  (radians)--	parallel : width in world coords

		float bias, 

		float sampSize,

		ULONG flags	)=0;

	virtual int UpdateViewDepParams(const Matrix3& worldToCam)=0;

	virtual	float Sample(float x, float y, float z, float xslope, float yslope)=0;

	virtual BOOL QuickSample(int x, int y, float z)=0; // this just tells you if the given point is in a shadow.

	virtual float FiltSample(int x, int y, float z,int level)=0;

	virtual float LineSample(int x1, int y1, float z1,int x2, int y2, float z2) {return 1.0f;}

	virtual void DeleteThis()=0;

	};



class ShadowQuadTree { 

	public:

	virtual int Update(

		const ObjLightDesc &light,

		const RendContext& rendCntxt,

		Matrix3& lightToWorld, // light to world space

		float aspect, // non-square

		float param,  // persp:field-of-view  (radians)-- parallel : width in world coords

		float bias, 

		ULONG flags	)=0;



	// update state that depends on view matrix.

	virtual int UpdateViewDepParams(const Matrix3& worldToCam)=0;

	virtual float Sample(ShadeContext& sc, 

		Point3 p,  // Point in camera space

		Color& color

		)=0;

	virtual void DeleteThis()=0;

	};





//--- Atmospheric plug-in interfaces -----------------------------------------------



// Returned by an atmospheric effect when it is asked to put up its rollup page.

class AtmosParamDlg {

	public:

		virtual Class_ID ClassID()=0;

		virtual void SetThing(ReferenceTarget *m)=0;

		virtual ReferenceTarget* GetThing()=0;

		virtual void SetTime(TimeValue t) {}		

		virtual void DeleteThis()=0;		

	};



// Atmospheric plug-in base class

class Atmospheric : public ReferenceTarget {

	public:		

		RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 

	         PartID& partID,  RefMessage message) {return REF_SUCCEED;}

		SClass_ID SuperClassID() {return ATMOSPHERIC_CLASS_ID;}

		

		// This name will appear in the track view and the list of current atmospheric effects.

		virtual TSTR GetName() {return _T("");}



		// Put up a modal dialog that lets the user edit the plug-ins parameters.

		virtual AtmosParamDlg *CreateParamDialog(IRendParams *ip) {return NULL;}



		// Called when the render steps to a new frame

		virtual	void Update(TimeValue t, Interval& valid) {}



		// This is the function that is called to apply the effect.

		virtual void Shade(ShadeContext& sc,const Point3& p0,const Point3& p1,Color& color, Color& trans, BOOL isBG=FALSE)=0;

	};





#endif