iparamm2.h File Reference

#include "maxheap.h"
#include "iparamb2.h"
#include "render.h"
#include "pbbitmap.h"

Classes
class	ParamMap2UserDlgProc
class	IParamMap2
class	IAutoMParamDlg
class	IAutoEParamDlg
class	IAutoRendererParamDlg
	Implementation of a ParamDlg that handles the automatic creation and lifetime management for a parameter map of a renderer plugin. More...

Functions
PB2Export BOOL	CreateModalParamMap2 (MapID map_id, IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, const MCHAR *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
BOOL	CreateModalParamMap2 (IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, const MCHAR *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
PB2Export BOOL	CreateModalParamMap2 (MapID map_id, IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
BOOL	CreateModalParamMap2 (IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
PB2Export IParamMap2 *	CreateChildModalParamMap2 (MapID map_id, IParamBlock2 *pb, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *proc=NULL)
IParamMap2 *	CreateChildModalParamMap2 (IParamBlock2 *pb, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *proc=NULL)
PB2Export IParamMap2 *	CreateModelessParamMap2 (MapID map_id, IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
IParamMap2 *	CreateModelessParamMap2 (IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
PB2Export IParamMap2 *	CreateModelessParamMap2 (MapID map_id, IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, const MCHAR *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
IParamMap2 *	CreateModelessParamMap2 (IParamBlock2 *pb, TimeValue t, HINSTANCE hInst, const MCHAR *dlgTemplate, HWND hParent, ParamMap2UserDlgProc *proc=NULL)
PB2Export void	DestroyModelessParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateChildModalParamMap2 (MapID map_id, IParamBlock2 *pb, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *proc=NULL)
IParamMap2 *	CreateChildModalParamMap2 (IParamBlock2 *pb, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *proc=NULL)
PB2Export void	DestroyChildModalParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateCPParamMap2 (MapID map_id, IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
IParamMap2 *	CreateCPParamMap2 (IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateCPParamMap2 (MapID map_id, IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
IParamMap2 *	CreateCPParamMap2 (IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateCPParamMap2 (MapID map_id, IParamBlock2 *pb, Interface *ip, MaxSDK::QMaxParamBlockWidget &qtWidget, const MCHAR *title, DWORD flags, int category=ROLLUP_CAT_STANDARD)
	Creates a parameter map which manages a Qt dialog, in the command panel. More...
PB2Export void	DestroyCPParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateChildCPParamMap2 (MapID map_id, IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildCPParamMap2 (IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export IParamMap2 *	CreateChildCPParamMap2 (MapID map_id, IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildCPParamMap2 (IParamBlock2 *pb, Interface *ip, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export void	DestroyChildCPParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
IParamMap2 *	CreateRParamMap2 (IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, MaxSDK::QMaxParamBlockWidget &qtDialog, const MCHAR *title, DWORD flags, int category=ROLLUP_CAT_STANDARD)
	Creates a parameter map which manages a Qt dialog, in the Render Settings panel or in the Environment panel. More...
PB2Export IParamMap2 *	CreateRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, MaxSDK::QMaxParamBlockWidget &qtDialog, const Class_ID &tabID, const MCHAR *title, DWORD flags, int category=ROLLUP_CAT_STANDARD)
	Creates a parameter map which manages a Qt dialog, in the Render Settings panel or in the Environment panel. More...
IParamMap2 *	CreateRParamMap2 (IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export void	DestroyRParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateChildRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildRParamMap2 (IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, IParamMap2 *parent, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export IParamMap2 *	CreateChildRParamMap2 (MapID map_id, IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildRParamMap2 (IParamBlock2 *pb, IRendParams *ip, HINSTANCE hInst, IParamMap2 *parent, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export void	DestroyChildRParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateMParamMap2 (MapID map_id, IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
IParamMap2 *	CreateMParamMap2 (IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateMParamMap2 (MapID map_id, IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IParamMap2 *	CreateMParamMap2 (MapID map_id, IParamBlock2 *pb, IMtlParams *ip, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, MaxSDK::QMaxParamBlockWidget &qtDialog, const MCHAR *title, DWORD flags, int category=ROLLUP_CAT_STANDARD)
	Creates a parameter map which manages a Qt dialog, in the material editor. More...
IParamMap2 *	CreateMParamMap2 (IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export void	DestroyMParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateChildMParamMap2 (MapID map_id, IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, IParamMap2 *parent, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildMParamMap2 (IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, IParamMap2 *parent, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, const MCHAR *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export IParamMap2 *	CreateChildMParamMap2 (MapID map_id, IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, IParamMap2 *parent, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
IParamMap2 *	CreateChildMParamMap2 (IParamBlock2 *pb, IMtlParams *ip, HINSTANCE hInst, IParamMap2 *parent, HWND hmedit, TexDADMgr *tdad, MtlDADMgr *mdad, DLGTEMPLATE *dlgTemplate, const MCHAR *title, ParamMap2UserDlgProc *dlgProc=NULL)
PB2Export void	DestroyChildMParamMap2 (IParamMap2 *m)
PB2Export IParamMap2 *	CreateRWParamMap2 (MapID map_id, IParamBlock2 *pb, IRollupWindow *rw, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, BOOL bindPBlockToMap=TRUE)
IParamMap2 *	CreateRWParamMap2 (IParamBlock2 *pb, IRollupWindow *rw, HINSTANCE hInst, const MCHAR *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, BOOL bindPBlockToMap=TRUE)
PB2Export IParamMap2 *	CreateRWParamMap2 (MapID map_id, IParamBlock2 *pb, IRollupWindow *rw, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, BOOL bindPBlockToMap=TRUE)
IParamMap2 *	CreateRWParamMap2 (IParamBlock2 *pb, IRollupWindow *rw, HINSTANCE hInst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, DWORD flags, ParamMap2UserDlgProc *dlgProc=NULL, BOOL bindPBlockToMap=TRUE)
PB2Export void	DestroyRWParamMap2 (IParamMap2 *m)
PB2Export IAutoMParamDlg *	CreateAutoMParamDlg (MapID map_id, HWND hMedit, IMtlParams *i, ReferenceTarget *obj, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, const MCHAR *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
IAutoMParamDlg *	CreateAutoMParamDlg (HWND hMedit, IMtlParams *i, ReferenceTarget *obj, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, const MCHAR *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IAutoMParamDlg *	CreateAutoMParamDlg (MapID map_id, HWND hMedit, IMtlParams *i, ReferenceTarget *obj, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
IAutoMParamDlg *	CreateAutoMParamDlg (HWND hMedit, IMtlParams *i, ReferenceTarget *obj, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, HWND hOldRollup=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IAutoMParamDlg *	CreateAutoMParamDlg (MapID map_id, HWND hMedit, IMtlParams *i, ReferenceTarget *obj, IParamBlock2 *pb, ClassDesc2 *cd, MaxSDK::QMaxParamBlockWidget &qtWidget, const MCHAR *title, int rollFlags, int category=ROLLUP_CAT_STANDARD)
	Creates a Qt-based ParamDlg, for use in the material editor, which automatically manages the creation and lifetime of the underlying parameter map. More...
PB2Export IAutoEParamDlg *	CreateAutoEParamDlg (MapID map_id, IRendParams *i, SpecialFX *e, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, const MCHAR *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
IAutoEParamDlg *	CreateAutoEParamDlg (IRendParams *i, SpecialFX *e, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, const MCHAR *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IAutoEParamDlg *	CreateAutoEParamDlg (MapID map_id, IRendParams *i, SpecialFX *e, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
IAutoEParamDlg *	CreateAutoEParamDlg (IRendParams *i, SpecialFX *e, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
PB2Export IAutoEParamDlg *	CreateAutoEParamDlg (MapID map_id, IRendParams *i, SpecialFX *e, IParamBlock2 *pb, ClassDesc2 *cd, MaxSDK::QMaxParamBlockWidget &qtWidget, const MCHAR *title, int rollFlags, int category=ROLLUP_CAT_STANDARD)
	Creates a Qt-based ParamDlg, for use in the environment panel, which automatically manages the creation and lifetime of the underlying parameter map. More...
PB2Export IAutoRendererParamDlg *	CreateAutoRenderParamDlg (MapID map_id, IRendParams *ip, Renderer &renderer, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, const MCHAR *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
	Creates a Win32-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map. More...
PB2Export IAutoRendererParamDlg *	CreateAutoRenderParamDlg (MapID map_id, IRendParams *ip, Renderer &renderer, IParamBlock2 *pb, ClassDesc2 *cd, HINSTANCE inst, DLGTEMPLATE *dlgTemplate, const MCHAR *title, int rollFlags, ParamMap2UserDlgProc *dlgProc=NULL, int category=ROLLUP_CAT_STANDARD)
	Creates a Win32-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map. More...
PB2Export IAutoRendererParamDlg *	CreateAutoRenderParamDlg (MapID map_id, IRendParams *ip, Renderer &renderer, IParamBlock2 *pb, ClassDesc2 *cd, MaxSDK::QMaxParamBlockWidget &qtDialog, const MCHAR *title, int rollFlags, int category=ROLLUP_CAT_STANDARD)
	Creates a Qt-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map. More...
PB2Export IAutoRendererParamDlg *	CreateAutoRenderParamDlg (MapID map_id, IRendParams *ip, Renderer &renderer, IParamBlock2 *pb, ClassDesc2 *cd, MaxSDK::QMaxParamBlockWidget &qtDialog, const Class_ID &tabID, const MCHAR *title, int rollFlags, int category=ROLLUP_CAT_STANDARD)
	Creates a Qt-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map. More...

Function Documentation

CreateModalParamMap2() [1/4]

PB2Export BOOL CreateModalParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		TimeValue	t,
		HINSTANCE	hInst,
		const MCHAR *	dlgTemplate,
		HWND	hParent,
		ParamMap2UserDlgProc *	proc = NULL
	)

Remarks

Creates a parameter map that will handle a parameter block in a modeless dialog where time does not change and the viewports are not redrawn. This overload of CreateModalParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateModalParamMap2() [2/4]

BOOL CreateModalParamMap2 ( IParamBlock2 *  pb, TimeValue  t, HINSTANCE  hInst, const MCHAR *  dlgTemplate, HWND  hParent, ParamMap2UserDlgProc *  proc = NULL  )

inline

Remarks

This function creates a parameter map that will handle a parameter block in a modeless dialog where time does not change and the viewports are not redrawn. Note that there is no need to destroy it. It executes the dialog and then destorys itself.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateModalParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

TimeValue t

The time at which the dialog is launched.

HINSTANCE hInst

The plug-ins instance handle.

MCHAR *dlgTemplate

The dialog template.

HWND hParent

The parent window.

ParamMap2UserDlgProc *proc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns TRUE if the user selected OK, FALSE otherwise.

                                         { return CreateModalParamMap2(0, pb, t, hInst, dlgTemplate, hParent, proc); } 

CreateModalParamMap2() [3/4]

PB2Export BOOL CreateModalParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		TimeValue	t,
		HINSTANCE	hInst,
		DLGTEMPLATE *	dlgTemplate,
		HWND	hParent,
		ParamMap2UserDlgProc *	proc = NULL
	)

CreateModalParamMap2() [4/4]

BOOL CreateModalParamMap2 ( IParamBlock2 *  pb, TimeValue  t, HINSTANCE  hInst, DLGTEMPLATE *  dlgTemplate, HWND  hParent, ParamMap2UserDlgProc *  proc = NULL  )

inline

Remarks

This function creates a parameter map that will handle a parameter block in a modeless dialog where time does not change and the viewports are not redrawn. Note that there is no need to destroy it. It executes the dialog and then destorys itself. This function is currently not in use.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

TimeValue t

The time at which the dialog is launched.

HINSTANCE hInst

The plug-ins instance handle.

DLGTEMPLATE *dlgTemplate

The dialog template.

HWND hParent

The parent window.

ParamMap2UserDlgProc *proc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns TRUE if the user selected OK, FALSE otherwise.

                                         { return CreateModalParamMap2(0, pb, t, hInst, dlgTemplate, hParent, proc); } 

CreateChildModalParamMap2() [1/4]

PB2Export IParamMap2* CreateChildModalParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	proc = NULL
	)

CreateChildModalParamMap2() [2/4]

IParamMap2* CreateChildModalParamMap2 ( IParamBlock2 *  pb, HINSTANCE  hInst, IParamMap2 *  parent, const MCHAR *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  proc = NULL  )

inline

                                         { return CreateChildModalParamMap2(0, pb, hInst, parent, dlgTemplate, title, proc); }

CreateModelessParamMap2() [1/4]

PB2Export IParamMap2* CreateModelessParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		TimeValue	t,
		HINSTANCE	hInst,
		DLGTEMPLATE *	dlgTemplate,
		HWND	hParent,
		ParamMap2UserDlgProc *	proc = NULL
	)

CreateModelessParamMap2() [2/4]

IParamMap2* CreateModelessParamMap2 ( IParamBlock2 *  pb, TimeValue  t, HINSTANCE  hInst, DLGTEMPLATE *  dlgTemplate, HWND  hParent, ParamMap2UserDlgProc *  proc = NULL  )

inline

                                         { return CreateModelessParamMap2(0, pb, t, hInst, dlgTemplate, hParent, proc); } 

CreateModelessParamMap2() [3/4]

PB2Export IParamMap2* CreateModelessParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		TimeValue	t,
		HINSTANCE	hInst,
		const MCHAR *	dlgTemplate,
		HWND	hParent,
		ParamMap2UserDlgProc *	proc = NULL
	)

CreateModelessParamMap2() [4/4]

IParamMap2* CreateModelessParamMap2 ( IParamBlock2 *  pb, TimeValue  t, HINSTANCE  hInst, const MCHAR *  dlgTemplate, HWND  hParent, ParamMap2UserDlgProc *  proc = NULL  )

inline

                                         { return CreateModelessParamMap2(0, pb, t, hInst, dlgTemplate, hParent, proc); } 

DestroyModelessParamMap2()

PB2Export void DestroyModelessParamMap2

(

IParamMap2 *

m

)

CreateChildModalParamMap2() [3/4]

PB2Export IParamMap2* CreateChildModalParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	proc = NULL
	)

CreateChildModalParamMap2() [4/4]

IParamMap2* CreateChildModalParamMap2 ( IParamBlock2 *  pb, HINSTANCE  hInst, IParamMap2 *  parent, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  proc = NULL  )

inline

                                         { return CreateChildModalParamMap2(0, pb, hInst, parent, dlgTemplate, title, proc); }

DestroyChildModalParamMap2()

PB2Export void DestroyChildModalParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateChildModalParamMap2().

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateCPParamMap2() [1/5]

PB2Export IParamMap2* CreateCPParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		Interface *	ip,
		HINSTANCE	hInst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Remarks

Creates a parameter map to handle the display of parameters in the command panel. This overload of CreateCPParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateCPParamMap2() [2/5]

IParamMap2* CreateCPParamMap2 ( IParamBlock2 *  pb, Interface *  ip, HINSTANCE  hInst, const MCHAR *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

This function creates a parameter map to handle the display of parameters in the command panel. This will add a rollup page to the command panel (or optionally replace an existing one).

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateCPParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

Interface *ip

Pass in the plug-ins interface pointer.

HINSTANCE hInst

The plug-ins instance handle.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL,

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

HWND hOldRollup=NULL

If non-NULL specifies an existing rollup window in the current UI context that should be replaced with the newly created rollup for this map.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Allthough it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2.

                                             { return CreateCPParamMap2(0, pb, ip, hInst, dlgTemplate, title, flags, dlgProc, hOldRollup, category); }

CreateCPParamMap2() [3/5]

PB2Export IParamMap2* CreateCPParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		Interface *	ip,
		HINSTANCE	hInst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

CreateCPParamMap2() [4/5]

IParamMap2* CreateCPParamMap2 ( IParamBlock2 *  pb, Interface *  ip, HINSTANCE  hInst, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

This function creates a parameter map to handle the display of parameters in the command panel. This will add a rollup page to the command panel (or optionally replace an existing one). This function is currently not used.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

Interface *ip

Pass in the plug-ins interface pointer.

HINSTANCE hInst

The plug-ins instance handle.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL,

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

HWND hOldRollup=NULL

If non-NULL specifies an existing rollup window in the current UI context that should be replaced with the newly created rollup for this map.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Allthough it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2.

                                             { return CreateCPParamMap2(0, pb, ip, hInst, dlgTemplate, title, flags, dlgProc, hOldRollup, category); }

CreateCPParamMap2() [5/5]

PB2Export IParamMap2* CreateCPParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		Interface *	ip,
		MaxSDK::QMaxParamBlockWidget &	qtWidget,
		const MCHAR *	title,
		DWORD	flags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a parameter map which manages a Qt dialog, in the command panel.

For more information on using Qt widgets with parameter maps, see: Qt in Parameter Maps and Parameter Blocks.

Parameters

map_id	The ID of the parameter map, useful if multiple rollups should be created for the same parameter block. Pass 0 if not creating multiple maps.
pb	The param block to be controlled by the parameter map.
ip	The interface passed to Animatable::BeginEditParams().
qtWidget	The Qt widget which forms the dialog to be controlled. This widget will be inserted into the rollout. The parameter map assumes the ownership of the widget and will delete when it gets destroyed.
title	The title of the rollout.
flags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The parameter map which controls the relationship between the UI dialog and the parameter block.

DestroyCPParamMap2()

PB2Export void DestroyCPParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateCParamMap2(). The rollup page is removed and the parameter map is deleted.

Parameters:

IParamMap2 *m

A pointer to the parameter map2 to delete.

CreateChildCPParamMap2() [1/4]

PB2Export IParamMap2* CreateChildCPParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		Interface *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

Remarks

Create a child dialog of the given parent command panel parammap (for tabbed dialogs, etc.) This overload of CreateChildCPParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateChildCPParamMap2() [2/4]

IParamMap2* CreateChildCPParamMap2 ( IParamBlock2 *  pb, Interface *  ip, HINSTANCE  hInst, IParamMap2 *  parent, const MCHAR *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

Remarks

This function creates a child dialog of the given parent parammap (for tabbed dialogs, etc.). This version takes an extra parent IParamMap2* and creates a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateChildCPParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

Interface *ip

Pass in the plug-ins rendering parameters interface pointer.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns a pointer to the parameter map2.

                                            { return CreateChildCPParamMap2(0, pb, ip, hInst, parent, dlgTemplate, title, dlgProc); }

CreateChildCPParamMap2() [3/4]

PB2Export IParamMap2* CreateChildCPParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		Interface *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

CreateChildCPParamMap2() [4/4]

IParamMap2* CreateChildCPParamMap2 ( IParamBlock2 *  pb, Interface *  ip, HINSTANCE  hInst, IParamMap2 *  parent, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

Remarks

This function creates a child dialog of the given parent parammap (for tabbed dialogs, etc.). This version takes an extra parent IParamMap2* and creates a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms. This function is currently not used.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

Interface *ip

Pass in the plug-ins rendering parameters interface pointer.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns a pointer to the parameter map2.

                                            { return CreateChildCPParamMap2(0, pb, ip, hInst, parent, dlgTemplate, title, dlgProc); }

DestroyChildCPParamMap2()

PB2Export void DestroyChildCPParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateChildCPParamMap2().

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateRParamMap2() [1/6]

PB2Export IParamMap2* CreateRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		HINSTANCE	hInst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Remarks

Creates a parameter map to handle the display of render parameters or atmospheric plug-in parameters. This overload of CreateRParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateRParamMap2() [2/6]

IParamMap2* CreateRParamMap2 ( IParamBlock2 *  pb, IRendParams *  ip, HINSTANCE  hInst, const MCHAR *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

Creates a parameter map to handle the display of render parameters or atmospheric plug-in parameters.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateRParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IRendParams *ip

Pass in the plug-ins rendering parameters interface pointer. See Class IRendParams.

HINSTANCE hInst

The plug-ins instance handle.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Allthough it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2.

                                            { return CreateRParamMap2(0, pb, ip, hInst, dlgTemplate, title, flags, dlgProc, category); }

CreateRParamMap2() [3/6]

PB2Export IParamMap2* CreateRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		HINSTANCE	hInst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

CreateRParamMap2() [4/6]

PB2Export IParamMap2* CreateRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		MaxSDK::QMaxParamBlockWidget &	qtDialog,
		const MCHAR *	title,
		DWORD	flags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a parameter map which manages a Qt dialog, in the Render Settings panel or in the Environment panel.

For more information on using Qt widgets with parameter maps, see: Qt in Parameter Maps and Parameter Blocks.

Parameters

map_id	The ID of the parameter map, useful if multiple rollups should be created for the same parameter block. Pass 0 if not creating multiple maps.
pb	The param block to be controlled by the parameter map.
ip	The interface passed to Renderer::CreateParamDialog().
qtDialog	The Qt widget which forms the dialog to be controlled. This widget will be inserted into the rollout. The parameter map assumes the ownership of the widget and will delete when it gets destroyed.
title	The title of the rollout.
flags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The parameter map which controls the relationship between the UI dialog and the parameter block.

CreateRParamMap2() [5/6]

PB2Export IParamMap2* CreateRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		MaxSDK::QMaxParamBlockWidget &	qtDialog,
		const Class_ID &	tabID,
		const MCHAR *	title,
		DWORD	flags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a parameter map which manages a Qt dialog, in the Render Settings panel or in the Environment panel.

For more information on using Qt widgets with parameter maps, see: Qt in Parameter Maps and Parameter Blocks.

Parameters

map_id	The ID of the parameter map, useful if multiple rollups should be created for the same parameter block. Pass 0 if not creating multiple maps.
pb	The param block to be controlled by the parameter map.
ip	The interface passed to Renderer::CreateParamDialog().
qtDialog	The Qt widget which forms the dialog to be controlled. This widget will be inserted into the rollout. The parameter map assumes the ownership of the widget and will delete when it gets destroyed.
tabID	Identifier for the tab in which the rollup is to be added. This is the ID used to create new tabs in implementations of ITabDialogObject::AddTabToDialog().
title	The title of the rollout.
flags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The parameter map which controls the relationship between the UI dialog and the parameter block.

CreateRParamMap2() [6/6]

IParamMap2* CreateRParamMap2 ( IParamBlock2 *  pb, IRendParams *  ip, HINSTANCE  hInst, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

Creates a parameter map to handle the display of render parameters or atmospheric plug-in parameters.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IRendParams *ip

Pass in the plug-ins rendering parameters interface pointer. See Class IRendParams.

HINSTANCE hInst

The plug-ins instance handle.

DLGTEMPLATE *dlgTemplate

The dialog template.

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Although it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2.

                                            { return CreateRParamMap2(0, pb, ip, hInst, dlgTemplate, title, flags, dlgProc, category); }

DestroyRParamMap2()

PB2Export void DestroyRParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateRParamMap2(). The rollup page is removed and the parameter map is deleted.

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateChildRParamMap2() [1/4]

PB2Export IParamMap2* CreateChildRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

Remarks

Creates a parameter map for render or atmospheric parameters in a child dialog window of the given parent parammap. This overload of CreateChildRParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateChildRParamMap2() [2/4]

IParamMap2* CreateChildRParamMap2 ( IParamBlock2 *  pb, IRendParams *  ip, HINSTANCE  hInst, IParamMap2 *  parent, const MCHAR *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

Remarks

This function create a parameter map for render or atmospheric parameters in a child dialog window of the given parent parammap, used typically to create tab child windows in a tabbed rollout. This version takes an extra parent IParamMap2* and creates a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateChildRParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IRendParams *ip

Pass in the plug-ins material parameters interface pointer. See Class IRendParams.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

MCHAR *dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR *title

The title displayed in the dialog.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns a pointer to the parameter map2 created.

                                            { return CreateChildRParamMap2(0, pb, ip, hInst, parent, dlgTemplate, title, dlgProc); }

CreateChildRParamMap2() [3/4]

PB2Export IParamMap2* CreateChildRParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRendParams *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

CreateChildRParamMap2() [4/4]

IParamMap2* CreateChildRParamMap2 ( IParamBlock2 *  pb, IRendParams *  ip, HINSTANCE  hInst, IParamMap2 *  parent, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

Remarks

This function create a parameter map for render or atmospheric parameters in a child dialog window of the given parent parammap, used typically to create tab child windows in a tabbed rollout. This version takes an extra parent IParamMap2* and creates a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms. This function is currently not being used.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IRendParams *ip

Pass in the plug-ins material parameters interface pointer. See Class IRendParams.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

DLGTEMPLATE *dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR *title

The title displayed in the dialog.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns a pointer to the parameter map2 created.

                                            { return CreateChildRParamMap2(0, pb, ip, hInst, parent, dlgTemplate, title, dlgProc); }

DestroyChildRParamMap2()

PB2Export void DestroyChildRParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateChildRParamMap2().

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateMParamMap2() [1/5]

PB2Export IParamMap2* CreateMParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IMtlParams *	ip,
		HINSTANCE	hInst,
		HWND	hmedit,
		TexDADMgr *	tdad,
		MtlDADMgr *	mdad,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Remarks

Creates a parameter map to handle the display of texture map or material parameters in the material editor. This overload of CreateMParamMap2() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateMParamMap2() [2/5]

IParamMap2* CreateMParamMap2 ( IParamBlock2 *  pb, IMtlParams *  ip, HINSTANCE  hInst, HWND  hmedit, TexDADMgr *  tdad, MtlDADMgr *  mdad, const MCHAR *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

Creates a parameter map to handle the display of texture map or material parameters in the material editor.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateMParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IMtlParams *ip

Pass in the plug-ins material parameters interface pointer. See Class IMtlParams.

HINSTANCE hInst

The plug-ins instance handle.

HWND hmedit

The window handle to the materials editor.

TexDADMgr* dad

Points to the manager used to handle drag and drop of textures. See Class TexDADMgr.

MtlDADMgr* mdad

Points to the manager used to handle drag and drop of materials. See Class MtlDADMgr.

MCHAR *dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

HWND hOldRollup=NULL

If non-NULL specifies an existing rollup window in the current UI context that should be replaced with the newly created rollup for this map.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Allthough it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2 created.

                                            { return CreateMParamMap2(0, pb, ip, hInst, hmedit, tdad, mdad, dlgTemplate, title, flags, dlgProc, hOldRollup, category); }

CreateMParamMap2() [3/5]

PB2Export IParamMap2* CreateMParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IMtlParams *	ip,
		HINSTANCE	hInst,
		HWND	hmedit,
		TexDADMgr *	tdad,
		MtlDADMgr *	mdad,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

CreateMParamMap2() [4/5]

PB2Export IParamMap2* CreateMParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IMtlParams *	ip,
		HWND	hmedit,
		TexDADMgr *	tdad,
		MtlDADMgr *	mdad,
		MaxSDK::QMaxParamBlockWidget &	qtDialog,
		const MCHAR *	title,
		DWORD	flags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a parameter map which manages a Qt dialog, in the material editor.

For more information on using Qt widgets with parameter maps, see: Qt in Parameter Maps and Parameter Blocks.

Parameters

map_id	The ID of the parameter map, useful if multiple rollups should be created for the same parameter block. Pass 0 if not creating multiple maps.
pb	The param block to be controlled by the parameter map.
ip	The interface passed to MtlBase::CreateParamDlg()
hmedit	The handle passed to MtlBase::CreateParamDlg()
tdad	An optional interface to manage drag-and-dropping of Texmap parameters.
mdad	An optional interface to manage drag-and-dropping of Mtl parameters.
qtDialog	The Qt widget which forms the dialog to be controlled. This widget will be inserted into the rollout. The parameter map assumes the ownership of the widget and will delete when it gets destroyed.
title	The title of the rollout.
flags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The parameter map which controls the relationship between the UI dialog and the parameter block.

CreateMParamMap2() [5/5]

IParamMap2* CreateMParamMap2 ( IParamBlock2 *  pb, IMtlParams *  ip, HINSTANCE  hInst, HWND  hmedit, TexDADMgr *  tdad, MtlDADMgr *  mdad, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

Creates a parameter map to handle the display of texture map or material parameters in the material editor. This function is currently not in use.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IMtlParams *ip

Pass in the plug-ins material parameters interface pointer. See Class IMtlParams.

HINSTANCE hInst

The plug-ins instance handle.

HWND hmedit

The window handle to the materials editor.

TexDADMgr* dad

Points to the manager used to handle drag and drop of textures. See Class TexDADMgr.

MtlDADMgr* mdad

Points to the manager used to handle drag and drop of materials. See Class MtlDADMgr.

DLGTEMPLATE *dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR *title

The title displayed in the rollup page title bar.

DWORD flags

A flag to control the settings of the rollup page:

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

HWND hOldRollup=NULL

If non-NULL specifies an existing rollup window in the current UI context that should be replaced with the newly created rollup for this map.

int category = ROLLUP_CAT_STANDARD

The category parameter provides flexibility with regard to where a particular rollup should be displayed in the UI. RollupPanels with lower category fields will be displayed before RollupPanels with higher category fields. For RollupPanels with equal category value the one that was added first will be displayed first. Although it is possible to pass any int value as category there exist currently 5 different category defines: ROLLUP_CAT_SYSTEM, ROLLUP_CAT_STANDARD, and ROLLUP_CAT_CUSTATTRIB.

When using ROLLUP_SAVECAT, the rollup page will make the provided category sticky, meaning it will not read the category from the RollupOrder.cfg file, but rather save the category field that was passed as argument in the CatRegistry and in the RollupOrder.cfg file.

The method will take the category of the replaced rollup in case the flags argument contains ROLLUP_USEREPLACEDCAT. This is mainly done, so that this system works with param maps as well.

Returns

Returns a pointer to the parameter map2 created.

                                            { return CreateMParamMap2(0, pb, ip, hInst, hmedit, tdad, mdad, dlgTemplate, title, flags, dlgProc, hOldRollup, category); }

DestroyMParamMap2()

PB2Export void DestroyMParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateMParamMap2(). The rollup page is removed and the parameter map is deleted.

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateChildMParamMap2() [1/4]

PB2Export IParamMap2* CreateChildMParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IMtlParams *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		HWND	hmedit,
		TexDADMgr *	tdad,
		MtlDADMgr *	mdad,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

Remarks

This function creates a child dialog of the given modal parent parammap (for tabbed dialogs, etc.). Unlike modal parent parammap, you do need to destroy it. This version takes an extra parent IParamMap2* and creates a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms.

Parameters:

MapID map_id

Specifies the ID of the parameter map/rollup to be created for this particular parameter block.

IParamBlock2 *pb

Points to the parameter block2.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

MCHAR *dlgTemplate

The dialog template.

MCHAR *title

The title displayed in the dialog.

ParamMap2UserDlgProc *proc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns TRUE if the user selected OK, FALSE otherwise.

CreateChildMParamMap2() [2/4]

IParamMap2* CreateChildMParamMap2 ( IParamBlock2 *  pb, IMtlParams *  ip, HINSTANCE  hInst, IParamMap2 *  parent, HWND  hmedit, TexDADMgr *  tdad, MtlDADMgr *  mdad, const MCHAR *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

Remarks

This function creates and returns a child dialog of the given parent parammap (for tabbed dialogs, etc.). This version takes an extra parent IParamMap2* and create a child dialog window in the parent parammap's window (rather than a new rollup) that is mapped by the new parammap. Developers need to call this explicitly once the parent parammap has been created as child parammaps are not created automatically by the P_AUTO_UI mechanisms.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateChildMParamMap2() with default map ID of 0.

Parameters:

IParamBlock2 *pb

Points to the parameter block2.

IMtlParams *ip

Pass in the plug-ins material parameters interface pointer. See Class IMtlParams.

HINSTANCE hInst

The plug-ins instance handle.

IParamMap2* parent

The parent parameter map.

TexDADMgr* tdad

Points to the manager used to handle drag and drop of textures. See Class TexDADMgr.

MtlDADMgr* mdad

Points to the manager used to handle drag and drop of materials. See Class MtlDADMgr_.

MCHAR *dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR *title

The title displayed in the dialog.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

Returns a pointer to the parameter map2 created.

                                            { return CreateChildMParamMap2(0, pb, ip, hInst, parent, hmedit, tdad, mdad, dlgTemplate, title, dlgProc); }

CreateChildMParamMap2() [3/4]

PB2Export IParamMap2* CreateChildMParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IMtlParams *	ip,
		HINSTANCE	hInst,
		IParamMap2 *	parent,
		HWND	hmedit,
		TexDADMgr *	tdad,
		MtlDADMgr *	mdad,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		ParamMap2UserDlgProc *	dlgProc = NULL
	)

CreateChildMParamMap2() [4/4]

IParamMap2* CreateChildMParamMap2 ( IParamBlock2 *  pb, IMtlParams *  ip, HINSTANCE  hInst, IParamMap2 *  parent, HWND  hmedit, TexDADMgr *  tdad, MtlDADMgr *  mdad, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, ParamMap2UserDlgProc *  dlgProc = NULL  )

inline

                                            { return CreateChildMParamMap2(0, pb, ip, hInst, parent, hmedit, tdad, mdad, dlgTemplate, title, dlgProc); }

DestroyChildMParamMap2()

PB2Export void DestroyChildMParamMap2

(

IParamMap2 *

m

)

Remarks

This function destroys a parameter map created by CreateChildMParamMap2().

Parameters:

IParamMap2 *m

Points to the parameter map2 to destroy.

CreateRWParamMap2() [1/4]

PB2Export IParamMap2* CreateRWParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRollupWindow *	rw,
		HINSTANCE	hInst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		BOOL	bindPBlockToMap = TRUE
	)

CreateRWParamMap2() [2/4]

IParamMap2* CreateRWParamMap2 ( IParamBlock2 *  pb, IRollupWindow *  rw, HINSTANCE  hInst, const MCHAR *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, BOOL  bindPBlockToMap = TRUE  )

inline

                                   { return CreateRWParamMap2(0, pb, rw, hInst, dlgTemplate, title, flags, dlgProc, bindPBlockToMap); }

CreateRWParamMap2() [3/4]

PB2Export IParamMap2* CreateRWParamMap2	(	MapID	map_id,
		IParamBlock2 *	pb,
		IRollupWindow *	rw,
		HINSTANCE	hInst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		DWORD	flags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		BOOL	bindPBlockToMap = TRUE
	)

CreateRWParamMap2() [4/4]

IParamMap2* CreateRWParamMap2 ( IParamBlock2 *  pb, IRollupWindow *  rw, HINSTANCE  hInst, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, DWORD  flags, ParamMap2UserDlgProc *  dlgProc = NULL, BOOL  bindPBlockToMap = TRUE  )

inline

                                   { return CreateRWParamMap2(0, pb, rw, hInst, dlgTemplate, title, flags, dlgProc, bindPBlockToMap); }

DestroyRWParamMap2()

PB2Export void DestroyRWParamMap2

(

IParamMap2 *

m

)

CreateAutoMParamDlg() [1/5]

PB2Export IAutoMParamDlg* CreateAutoMParamDlg	(	MapID	map_id,
		HWND	hMedit,
		IMtlParams *	i,
		ReferenceTarget *	obj,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Remarks

This function may be called to create a parameter map2 for use in the material editor dialog. This overload of CreateAutoMParamDlg() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateAutoMParamDlg() [2/5]

IAutoMParamDlg* CreateAutoMParamDlg ( HWND  hMedit, IMtlParams *  i, ReferenceTarget *  obj, IParamBlock2 *  pb, ClassDesc2 *  cd, HINSTANCE  inst, const MCHAR *  dlgTemplate, const MCHAR *  title, int  rollFlags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

This function may be called to create a parameter map2 for use in the material editor dialog.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateAutoMParamDlg() with default map ID of 0.

Parameters:

HWND hMedit

The window handle of the materials editor.

IMtlParams *i

The interface pointer for materials. See Class IMtlParams.

MtlBase* mtl

Points to the material calling this function.

IParamBlock2* pb

Points to the parameter block instance associated with the parameter map.

ClassDesc2* cd

The class descriptor2 for the plug-in creating the parameter map.

HINSTANCE inst

The plug-ins DLL instance handle.

MCHAR* dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR* title

The title displayed in the rollup page title bar.

int rollFlags

A set of flags to control settings of the rollup page.

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

HWND hOldRollup=NULL

An optional window handle to allow supplying an existing rollup that will be replaced by the newly cerated one.

Returns

A pointer to an interface for managing the parameter map2.

                                            {
                                                return CreateAutoMParamDlg(0, hMedit, i, obj, pb, cd, inst, dlgTemplate, 
                                                                           title, rollFlags, dlgProc, hOldRollup, category); 
                                            }

CreateAutoMParamDlg() [3/5]

PB2Export IAutoMParamDlg* CreateAutoMParamDlg	(	MapID	map_id,
		HWND	hMedit,
		IMtlParams *	i,
		ReferenceTarget *	obj,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		HWND	hOldRollup = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

CreateAutoMParamDlg() [4/5]

IAutoMParamDlg* CreateAutoMParamDlg ( HWND  hMedit, IMtlParams *  i, ReferenceTarget *  obj, IParamBlock2 *  pb, ClassDesc2 *  cd, HINSTANCE  inst, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, int  rollFlags, ParamMap2UserDlgProc *  dlgProc = NULL, HWND  hOldRollup = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

                                            {
                                                return CreateAutoMParamDlg(0, hMedit, i, obj, pb, cd, inst, dlgTemplate, 
                                                                           title, rollFlags, dlgProc, hOldRollup, category); 
                                            }

CreateAutoMParamDlg() [5/5]

PB2Export IAutoMParamDlg* CreateAutoMParamDlg	(	MapID	map_id,
		HWND	hMedit,
		IMtlParams *	i,
		ReferenceTarget *	obj,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		MaxSDK::QMaxParamBlockWidget &	qtWidget,
		const MCHAR *	title,
		int	rollFlags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Qt-based ParamDlg, for use in the material editor, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
hMedit	The handle passed to MtlBase::CreateParamDlg()
i	The interface passed to MtlBase::CreateParamDlg()
obj	The object (the MtlBase) for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
qtWidget	The Qt widget that will be shown in the dialog.
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

See also

Qt in Parameter Maps and Parameter Blocks

CreateAutoEParamDlg() [1/5]

PB2Export IAutoEParamDlg* CreateAutoEParamDlg	(	MapID	map_id,
		IRendParams *	i,
		SpecialFX *	e,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Remarks

This function creates an AutoEParamDlg for render effects. This overload of CreateAutoEParamDlg() has a new parameter, map_id, that specifies the ID of the parameter map/rollup to be created for this particular parameter block. See original function for the rest of the description.

CreateAutoEParamDlg() [2/5]

IAutoEParamDlg* CreateAutoEParamDlg ( IRendParams *  i, SpecialFX *  e, IParamBlock2 *  pb, ClassDesc2 *  cd, HINSTANCE  inst, const MCHAR *  dlgTemplate, const MCHAR *  title, int  rollFlags, ParamMap2UserDlgProc *  dlgProc = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

Remarks

This function creates an AutoEParamDlg for render effects.

Note, in version 4.0 and later, this actually maps to a call on the explicit map ID overload of CreateAutoEParamDlg() with default map ID of 0.

Parameters:

IRendParams *i

An interface pointer for rendering effects.

SpecialFX* e

Points to the rendering effect calling this function.

IParamBlock2* pb

Points to the parameter block instance associated with the parameter map.

ClassDesc2* cd

The class descriptor2 for the plug-in creating the parameter map.

HINSTANCE inst

The plug-ins DLL instance handle.

MCHAR* dlgTemplate

Dialog template for the rollup page (created using the resource editor)

MCHAR* title

The title displayed in the rollup page title bar.

int rollFlags

A set of flags to control settings of the rollup page.

APPENDROLL_CLOSED

Starts the page in the rolled up state.

ParamMap2UserDlgProc* dlgProc=NULL

If there is some custom handling required by a particular control, the client can derive a class from ParamMap2UserDlgProc and set it as the parameter map's user callback.

Returns

A pointer to an interface for managing the parameter map2.

                                            { 
                                                return CreateAutoEParamDlg(0, i, e, pb, cd, inst, dlgTemplate, title, rollFlags, dlgProc, category);
                                            }

CreateAutoEParamDlg() [3/5]

PB2Export IAutoEParamDlg* CreateAutoEParamDlg	(	MapID	map_id,
		IRendParams *	i,
		SpecialFX *	e,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

CreateAutoEParamDlg() [4/5]

IAutoEParamDlg* CreateAutoEParamDlg ( IRendParams *  i, SpecialFX *  e, IParamBlock2 *  pb, ClassDesc2 *  cd, HINSTANCE  inst, DLGTEMPLATE *  dlgTemplate, const MCHAR *  title, int  rollFlags, ParamMap2UserDlgProc *  dlgProc = NULL, int  category = ROLLUP_CAT_STANDARD  )

inline

                                            { 
                                                return CreateAutoEParamDlg(0, i, e, pb, cd, inst, dlgTemplate, title, rollFlags, dlgProc, category);
                                            }

CreateAutoEParamDlg() [5/5]

PB2Export IAutoEParamDlg* CreateAutoEParamDlg	(	MapID	map_id,
		IRendParams *	i,
		SpecialFX *	e,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		MaxSDK::QMaxParamBlockWidget &	qtWidget,
		const MCHAR *	title,
		int	rollFlags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Qt-based ParamDlg, for use in the environment panel, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
i	The interface passed to SpecialFX::CreateParamDialog().
e	The object for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
qtWidget	The Qt widget that will be shown in the dialog.
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

See also

Qt in Parameter Maps and Parameter Blocks

CreateAutoRenderParamDlg() [1/4]

PB2Export IAutoRendererParamDlg* CreateAutoRenderParamDlg	(	MapID	map_id,
		IRendParams *	ip,
		Renderer &	renderer,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		const MCHAR *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Win32-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
ip	The interface passed to Renderer::CreateParamDialog().
renderer	The object for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
inst	The HINSTANCE for the DLL that hosts the resources for the dialog template.
dlgTemplate	The dialog template to be used, specified as MAKEINTRESOURCE(resource_id).
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
dlgProc	An optional dialog procedure to do custom processing of window messages.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

CreateAutoRenderParamDlg() [2/4]

PB2Export IAutoRendererParamDlg* CreateAutoRenderParamDlg	(	MapID	map_id,
		IRendParams *	ip,
		Renderer &	renderer,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		HINSTANCE	inst,
		DLGTEMPLATE *	dlgTemplate,
		const MCHAR *	title,
		int	rollFlags,
		ParamMap2UserDlgProc *	dlgProc = NULL,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Win32-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
ip	The interface passed to Renderer::CreateParamDialog().
renderer	The object for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
inst	The HINSTANCE for the DLL that hosts the resources for the dialog template.
dlgTemplate	The dialog template to be used.
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
dlgProc	An optional dialog procedure to do custom processing of window messages.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

CreateAutoRenderParamDlg() [3/4]

PB2Export IAutoRendererParamDlg* CreateAutoRenderParamDlg	(	MapID	map_id,
		IRendParams *	ip,
		Renderer &	renderer,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		MaxSDK::QMaxParamBlockWidget &	qtDialog,
		const MCHAR *	title,
		int	rollFlags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Qt-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
ip	The interface passed to Renderer::CreateParamDialog().
renderer	The object for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
qtDialog	The Qt widget that will be shown in the dialog.
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

See also

Qt in Parameter Maps and Parameter Blocks

CreateAutoRenderParamDlg() [4/4]

PB2Export IAutoRendererParamDlg* CreateAutoRenderParamDlg	(	MapID	map_id,
		IRendParams *	ip,
		Renderer &	renderer,
		IParamBlock2 *	pb,
		ClassDesc2 *	cd,
		MaxSDK::QMaxParamBlockWidget &	qtDialog,
		const Class_ID &	tabID,
		const MCHAR *	title,
		int	rollFlags,
		int	category = ROLLUP_CAT_STANDARD
	)

Creates a Qt-based ParamDlg, for use in the render settings panel, which automatically manages the creation and lifetime of the underlying parameter map.

In most cases, this method shouldn't be used directly by plugin developers. Instead, the plugin should call ClassDesc2::CreateParamDlgs() to automatically create the ParamDlg for all dialogs flagged with P_AUTO_UI or P_AUTO_UI_QT. But if the plugin needs to manage (perhaps conditionally) the creation of its dialogs, then it may call this function directly for individual parameter maps.

Parameters

map_id	The ID of the parameter map for which to create the dialog.
ip	The interface passed to Renderer::CreateParamDialog().
renderer	The object for which the dialog is being created.
pb	The parameter block to which the parameter map is associated.
cd	The class descriptor of the object for which the dialog is being created.
qtDialog	The Qt widget that will be shown in the dialog.
tabID	Identifier for the tab in which the rollup is to be added. This is the ID used to create new tabs in implementations of ITabDialogObject::AddTabToDialog().
title	The title of the rollup window to be created.
rollFlags	Rollout flags, such as APPENDROLL_CLOSED.
category	A value controlling the order in which rollouts are positioned.

Returns

The ParamDlg which was created.

See also

Qt in Parameter Maps and Parameter Blocks