Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678910111213141516171819]

CActionDescription	Description of a command for building action tables from static data This is a helper structure used for building ActionTables
CActiveXLicensor
CArrayPointerDestructor< Type >	DestructorPolicy template for pointer to array types
CAutoPtr< Type, DestructorPolicy >	Automatic memory-ownership pointer supporting "resource acquisition is initialization
►CAutoPtr< AnimatableImplData >
CAutoPtr< AnimatableImplData >
CAutoPtr< AssetUserImp >
►CAutoPtr< ClassDirectoryImpl >
CAutoPtr< ClassDirectoryImpl >
►CAutoPtr< ClassEntryImpl >
CAutoPtr< ClassEntryImpl >
►CAutoPtr< DataClassDescImpl >
CAutoPtr< DataClassDescImpl >
►CAutoPtr< DependentEnumProcImplData >
CAutoPtr< DependentEnumProcImplData >
CAutoPtr< DllDescImpl >
CAutoPtr< DllDirImpl >
CAutoPtr< INormalDataGenerator >
►CAutoPtr< MtlBaseImplData >
CAutoPtr< MtlBaseImplData >
►CAutoPtr< PathImpl >
CAutoPtr< PathImpl >
►CAutoPtr< RefEnumProcImplData >
CAutoPtr< RefEnumProcImplData >
►CAutoPtr< ReferenceMakerImplData >
CAutoPtr< ReferenceMakerImplData >
►CAutoPtr< RemapDir >
CAutoPtr< RemapDir >
CAutoPtr< Storage >
►CAutoPtr< SubClassListImpl >
CAutoPtr< SubClassListImpl >
►CAutoPtr< Type >
CAutoPtr< Type >	Old AutoPtr class, maintained to support backwards compatibility
►CAutoPtr< Type, ArrayPointerDestructor< Type > >
CArrayAutoPtr< Type >	Standard implementation of a AutoPtr for pointer to array types
►CAutoPtr< Type, DeleteThisDestructor >
CDeleteThisAutoPtr< Type >	Partial template specialization of AutoPtr for types requiring destruction through a DeleteThis method
CAutoPtrRef< OtherType >	Helper class used to implement destructive copy semantics and allow for AutoPtrs to be used as return values
►CB
CAddExposureMaterialControl< B >	This class implements a small hack to get around issues in the VS2005 compiler
CExposureMaterialControlImp< T, B >	This class implements the virtual methods in ExposureMaterialControl
CBevelProfileCurveUser	A plugin which wants to use the Bevel Profile Curves should derive from this class and implement the following methods
CBevelProfileEditorInformation	This class provides information on the Bevel Profile Editor to plugins which want to use the standard editor (initially implemented by TextPlus)
Cbinding
CCallbackScript
►CCallContext
CSMCallContext
CCBoneDataClass
Cclass_key
Cclass_table
►CClassDescriptor public ClassDesc2
CUnifiedRenderer	Unifies functionality for, both, interactive (ActiveShade) and offline (Production) rendering
►CCollectable
►CValue
CBoolean
►CCharStream
CCharBinaryStream
CPipe
CReadonlyTextFileStream	ReadonlyTextFileStream is only used for opening text file in read-only mode
CCodeBlock
CCodeTree
CEmpty
CFPInterfaceValue
CFPMixinInterfaceValue
CFPStaticMethodInterfaceValue
►CFunction
►CGeneric
►CMappedGeneric
CNodeGeneric
►CInterfaceFunction
CActionPredicate
CInterfaceMethod
CStaticInterfaceMethod
CMAXScriptFunction
COLEMethod
►CPrimitive
CMappedPrimitive
CUserGenericValue
CHashTable
CIObjectValue
CListener
CMaker
CMAXClass
CMAXSuperClass
CMAXWrapper
CMenuItem
CMouseTool
CMSZipPackage
CNoValue
COk
COLEObject
►CParser
CDotRunParser
CPluginMethod
CRCMenu
CRollout
►CRolloutControl
CBitmapControl
►CButtonControl
CMapButtonControl
CMtlButtonControl
CCheckBoxControl
CCheckButtonControl
CColorPickerControl
CComboBoxControl
CEditTextControl
CGroupEndControl
CGroupStartControl
CLabelControl
CListBoxControl
CPickerControl
CRadioControl
CSliderControl
CSpinnerControl
CRolloutFloater
CSourceFileWrapper
CSourcePositionWrapper
CStructMethod
►CThunk
CCodeBlockLocalThunk
CContextThunk
CDerefThunk
►CFreeThunk
CIndirectFreeThunk
►CGlobalThunk
CConstGlobalThunk
CIndexThunk
►CLocalThunk
CIndirectLocalThunk
COwnerThunk
►CPluginLocalThunk
CConstPluginLocalThunk
CPluginParamThunk
►CPropertyThunk
CFnCallPropertyThunk
CRCMenuItemThunk
CRCMenuLocalThunk
CRolloutControlThunk
►CRolloutLocalThunk
CConstRolloutLocalThunk
CStructMemberThunk
CSystemGlobalThunk
CThunkReference
CToolLocalThunk
CUndefined
CUnsupplied
CValueHolder
CValueMetaClass
CCollection
CParamBlockData::ContainerTypeAndIndex	Is a data structure for parameter blocks container information Retrieve the parameter block that was updated in the references or custom attributes or whatever of the Object* from the INode* or Mtl* or Texmap* etc..
CDataNodeWrapper< HeldType_ >
CMaterialRequiredStreamElement::DataUnion
CDefaultTranslatorAllocator< TranslatorType >
CDeleteThisDestructor	DestructorPolicy template for types requiring destruction through DeleteThis
CRasterizerState::DepthBias	The z buffer depth bias value Default value is 0
CDumpValueData
Cedit_window
CEditFileResult
CEditor_Interface
CEditorStyleDef
CEvaluationContext	This struct is a collection of elements that are necessary in a render view
►CEXCEPINFO
CCExcepInfo
CFlyOffData
Cfree_mem
CGfxPickResult
►CGUID
CAssetId
CHashTabMapper
CIPhysicalCamera_BitmapApertureSampler::IApertureBitmapAccess	Interface used to provide generic access to the bitmap aperture
CICameraContainer	Abstracts the common properties of the camera to be rendered
►CICameraContainer::IChangeNotifier	Notification callback interface for ICameraContainer
CBaseTranslator_Camera	Base class for translating the scene camera
CBaseTranslator_INode	Base class for translating an INode
CIRenderSessionContext::IChangeNotifier	Notification callback interface for IRenderSessionContext
CIRenderSettingsContainer::IChangeNotifier	Notification callback interface for IRenderSettingsContainer
CISceneContainer::IChangeNotifier	Notification callback interface for ISceneContainer
►CIClassFactory
CMSClassFactory
►CIDataObject
►CDropType
CBitmapDropType
►CDropScriptDropType
CDropScriptFileDropType
CMSZipPackageFileDropType
►CFileDropType
CDropScriptFileDropType
CImageFileDropType
CImportFileDropType
CMSZipPackageFileDropType
CPathConfigDropType	A DropType class specific to path configuration files
CSceneFileDropType
CScriptFileDropType
►CIDispatch
CMSOLEObject
►CIDropSource
CDropType
CIFrameBufferProcessor	Generic interface for processing the contents of an frame buffer
CIFrameBufferProcessor::IFrameBufferReader	Generic interface for reading frame buffer data
►CIGenericEvent	IGenericEvent is a common class to all notifications events received:
CIMaterialEvent	You receive a IMaterialEvent instance when something is changed in a Material: Events monitored : all related to materials
►CINodeEvent	Base class for all events associated with notifier types: NotifierType_Node_*
CINodeParamBlockEvent	Event related to a parameter block change in a node's object
CINodePropertyEvent	Event related to a change in a node's object GI properties
CIReferenceTargetEvent	You receive a IReferenceTargetEvent instance when something is changed in a ReferenceTarget: Events monitored : all related to reference targetss
CISceneNodeEvent	You receive a ISceneNodeEvent instance when some nodes have been added/removed to/from the scene Event monitored: EventType_Scene_Node_Added/EventType_Scene_Node_Removed
CITexmapEvent	You receive a ITexmapEvent instance when something is changed in a Texmap: Events monitored : all related to texmaps
CIViewEvent	You receive a IViewEvent instance when something dealing with the view has changed: Events received with that class : EventType_View_Transform or EventType_View_Active
CIInteractiveRenderingCallback	InteractiveRenderingCallback is the the class to derive from to create a callback to receive events from InteractiveRendering
►CIInteractiveRenderingClient	Base class for Interactive Rendering clients
CIImmediateInteractiveRenderingClient	Immediate client is to get notifications as soon as they happen (by opposite to OnDemand client)
CIOnDemandInteractiveRenderingClient	Is a client where you get the notifications on demand, they are stored until you ask for them
CIInteractiveRenderingManager	IInteractiveRenderingManager class is the entry point of the Interactive Rendering API, you can create or remove a Interactive Rendering Client Interactive rendering API is a middle API that makes the link between the low level NotificationAPI and the customer
CIRenderingProcess::IMainThreadJob	Interface to a job which gets executed from the main thread
CISparseVertexWeights::Influence
CINodeInstancingPool	Abstracts a set of nodes that all point to the the same object instance
CINoSignalCheckProgress	An alternative progress reporting interface to class RendProgressCallback, which does not process the window message queue
►CINotificationCallback	The notification callback used to process all events from the notification API
CBaseTranslator_INode	Base class for translating an INode
CBaseTranslator_Object	Base class for translating the object referenced by a node instancing pool
►CBaseTranslator_ReferenceTarget	Base class for translating an arbitrary ReferenceTarget
►CBaseTranslator_MtlBase	Base class for translating a MtlBase
CBaseTranslator_Mtl	Base class for translating a material
►CBaseTranslator_Texmap	Base class for translating a Texmap
CBaseTranslator_Environment	Base class for translating an environment
►CINotificationClient	Base class for a notification client, is used to subscribe to notification events by monitoring 3ds Max data
►CIImmediateNotificationClient	Immediate client is to get notifications as soon as they happen (by opposite to OnDemand client)
CIImmediateInteractiveRenderingClient	Immediate client is to get notifications as soon as they happen (by opposite to OnDemand client)
CIOnDemandNotificationClient	Is a notification client where you get the notifications on demand, they are stored until you ask for them
CINotificationManager	INotificationManager class is the entry point of the Notification API, you can create or remove a Notification Client
►CINodeInstancingPool::INotifier	Notification callback for monitoring changes in a node instancing pool
CBaseTranslator_INode	Base class for translating an INode
CBaseTranslator_Object	Base class for translating the object referenced by a node instancing pool
CIPhysicalCamera_BitmapApertureSampler	Utility class that provides efficient sampling for a bitmap aperture on the physical camera
CIRefTargWrappingRefTarg	An interface for ReferenceTargets that wrap ReferenceTargets, where the wrapping ReferenceTarget provides UI/storage on top of the wrapped ReferenceTarget
CIRenderingProcess	The Rendering API's interface for managing the render process
CIRenderSessionContext	Encapsulates all that a render session needs to render a frame
CIRenderSettingsContainer	Abstracts the set of settings and parameters which may affect rendering
CISceneContainer	Abstracts the contents of the scene to be rendered
CMeshSubHitRec::Iterator
CPatchSubHitRec::Iterator
CITranslationProgress	Interface used for progress reporting by translators
Clayout_data
CListenerMessageData
►CMaxHeapOperators	The base class in Max that controls the memory management for any class that derives from it
CAColor
CActionContext	An ActionContext is an identifer of a group of keyboard shortcuts
CAdjEdgeList
CAdjFace
CAdjFaceList
CAffineParts
CAlertData
CAngAxis
CAnimatable::EnumAnimList	A callback class for enumerating animatables
CAnimateSuspend	Suspends the "animate" mode in an exception safe manner
►CAnimEnum	A callback class for Animatable::EnumAnimTree()
CClearAnimFlagEnumProc	An animatable enumerator for clearing flags
►CAnimProperty
CAnimAppData
CEaseCurveAnimProp
CInterpCtrlUI
CInterpKeyInfo
CIShapeRectRenderParams	Rectangular Shape Render Parameters API This interface gives access to the new Renderable SPline parameters for Rectangular Shapes The IShapeRectRenderParams interface can be retrieved like this: IShapeRectRenderParams* rparams = (IShapeRectRenderParams*)obj->GetProperty(SHAPE_RECT_RENDERPARAMS_PROPID); Note that this interface contains VPT and non VPT parameters
►CJointParams
CJointParams2
CMultCurveAnimProp
CNoteAnimProperty
CPStamp
CSchematicViewProperty
CAnyKey
CAppDataChunk	An application/plugin specific custom data that can be attached to animatables
CAppLoad
CAppSave
CArcballCallback
CArcballDialog
CAreaShadowSampler
CArray< bindShape >
CArray< CapFace >
CArray< CapPatch >
►CArray< DelayedOp >
CDelayedMatrix3::OpQueue
CArray< DialogItemSizeData >
CArray< DWORD >
CArray< ExprVar >
CArray< ExtrudeData >
►CArray< FLT_FilterHandler >
CFLT_FilterList
CArray< FPValue >
►CArray< GUPHandler >
CGUPList
CArray< int >
CArray< MaxSDK::Graphics::MeshElementDescription >
CArray< MaxSDK::Graphics::RenderItemHandle >
CArray< MaxSDK::Graphics::Utilities::MarkerConsolidationItem::ConsolidationData >
CArray< MaxSDK::Graphics::Utilities::MeshEdgeConsolidationItemDX11::ConsolidationData >
CArray< MaxSDK::Graphics::Utilities::SplineConsolidationItem::ConsolidationData >
CArray< MaxSDK::NotificationAPI::ParamBlockData::ContainerTypeAndIndex >
CArray< MaxSDK::SkinEngine::CBoneDataClass >
CArray< MaxSDK::SkinEngine::PointDataClass >
CArray< MeshCapVert >
CArray< ParserSourceData >
CArray< PatchCapVec >
CArray< PatchCapVert >
CArray< Point3 >
CArray< SSConstraintPoint >
CArray< SSParticle >
CArray< SSSpring >
CArray< TextureInfo >
CArray< UINT >
CArray< VertexBufferHandle >
CArray< WStr >
►CAssetEnumCallback
CIEnumAuxAssetsCallback	An extension of AssetEnumCallback that exposes an interface for providing more detailed information about an asset
CATSClientInfo	Client information for ATS Providers
CATSExploreProviderParams	ATS Explore Provider Object
CATSFileEntry	ATS File Object
CATSFileList	ATS File List
CATSNotification	Register for and Broadcast ATS Notification Messages
CATSNotifyParams	Asset Tracking System Notification Parameter class
CATSUserEntry	ATS User Object
CATSUserList	ATS User List
►CAttachMatDlgUser
CPatchObject
CSplineShape
CAvailableFont	A class used for listing the fonts we currently have available
CAxisChangeCallback
CBasisFinder	Computes two components of a basis vector given a single input component
►CBezFont	This class is the basic bezier font class
►CBezFontEX	This class extends BezFont class It adds GetFont() which returns the font handle currently opened
CBezFontEX2	This class extends the BezFontEX class which extends the function BuildCharacter() to obtain glyph outline data from a character based on its TrueType glyph index
CBezFontDll	A class for listing font input dlls
CBezFontEnumProc	This is a callback class which is used to process font enumerations
CBezFontInfo
CBezFontManager	Manages Bezier Fonts in 3ds Max
CBezFontMetrics
CBezFontMgrEnumProc	A special enumerator for the font manager
CBezierShapeTopology
CBigMatrix
CbindShape	Contains the data for the bind points
CBitArray
CBitArray::NumberSetProxy
►CBitArrayCallback
COrbazTrueBlockEnumerator
COrbazTrueEnumerator
CBitmapDither
CBitmapFileInputDialog	Custom browse bitmap file for input dialog
CBitmapFileOutputDialog	Custom browse bitmap file for output dialog
CBitmapFilter
CBitmapInfo	Information about an image file or in-memory bitmap, including settings for loading/saving, gamma, etc
CBitmapNotify
CBitmapProxyTemporaryDisableGuard	Useful Guard class for temporarily disabling bitmap proxies
CBMM_Color_24	24 bit color: 8 bits each for Red, Green, and Blue
CBMM_Color_32	32 bit color: 8 bits each for Red, Green, Blue, and Alpha
CBMM_Color_48	48 bit color: 16 bits each for Red, Green, and Blue
CBMM_Color_64	64 bit color: 16 bits each for Red, Green, Blue, and Alpha
CBMM_Color_fl	High Dynamic Range bitmaps make use of this class to store color information using floating point values
CBMM_IOHandler
CBMM_Pyramid
CBMM_SAT
CBMMBitmapList
CBMMFilterList
CBMMGammaSettings
CbmmHistoryList
CBMMImageInfo
CBMMStorageList
CBMMVfbPalette
CBox2
CBox2D
CBox3
CCacheClass
CCameraState	Note: The camera looks down the negative Z axis, with X to the right and Y up
CCandidate
CCapFace
CCapPatch
CCapVert
CCAssertCB	Callback class that allows for hooking into 3ds Max's assertion mechanims
►CChangeForegroundCallback
CChangeFGObject
CCIRCLE	Represents a circular region when doing hit testing
CCJobText
CClass_ID
►CClassDesc	Class descriptors provide the system with information about the plug-in classes in the DLL
►CClassDesc2
CPFActionStateDesc
CDataClassDesc	A proxy for a class descriptor
CClassDescReplaced	CallParam data for NOTIFY_CLASSDESC_REPLACED broadcasts
CClassEntry	This class wraps a ClassDesc instance and maintains run-time related information about it
CClientInfo
CCollisionVNormal
CColor
CColor24	8 bits for each of the Red, Green and Blue components
CColor48	16 bits for each of the Red, Green and Blue components
CColor64	16 bits for each of the Red, Green, Blue, and Alpha components
CColorPacker
CCombustionJob
►CCommandMode	This base class allows the developer to create a command mode that handles processing user interaction using the mouse in the viewports
CEditSSMode	Edit Soft Selection Command Mode for interactively setting soft selection parameters
CEP_BevelCMode
CEP_BindCMode
CEP_CopyTangentCMode
CEP_CreatePatchCMode
CEP_CreateVertCMode
CEP_ExtrudeCMode
CEP_NormalFlipCMode
CEP_PasteTangentCMode
CEP_VertWeldCMode
CMouseToolCommandMode
CMoveCtrlApparatusCMode
CMoveModBoxCMode
CNUScaleCtrlApparatusCMode
CNUScaleModBoxCMode
CPickCommandMode	Derive your command mode class from this one if you wish to implement your own pick command mode and want to hook it into the select by name mechanism
CRotateCtrlApparatusCMode
CRotateModBoxCMode
CSelectCtrlApparatusCMode
CSelectModBoxCMode
CSquashCtrlApparatusCMode
CSquashModBoxCMode
CSSBindCMode
CSSBooleanCMode
CSSChamferCMode
CSSCopyTangentCMode
CSSCreateLineCMode
CSSCrossInsertCMode
CSSCrossSectionCMode
CSSExtendCMode
CSSFilletCMode
CSSOutlineCMode
CSSPasteTangentCMode
CSSRefineConnectCMode
CSSSegBreakCMode
CSSSegRefineCMode
CSSTrimCMode
CSSVertConnectCMode
CSSVertInsertCMode
CUScaleCtrlApparatusCMode
CUScaleModBoxCMode
►CCommandModeChangedCallback
CMouseToolCommandMode
CConfigurationBlock
CConstraintInOut	This structure is sent to the BaseBehavior Constraint function
CCreateInstanceCallParam
►CCreateMouseCallBack
COneClickCreateCallBack
CCreateRendImgSeqCallback	A callback object called for each sequence file created with Interface8::CreateRendImgSeq()
CCropCallback
CCStr
CCtrlHitLog	Class CtrlHitLog
CCtrlHitRecord	Class CtrlHitRecord
CCUIFrameMsgHandler
CCUIPosData
CCurvePoint
CCustomParticleDisplay
CDefaultActionSys	The Default Action System interface
CDefaultLight	Describes a default light
CDeformer	The callback object used by modifiers to deform "Deformable" objects
CDelayedMatrix3::DelayedOp
►CDependentEnumProc	A callback class for enumerating dependents
CFindCustAttribOwnerDEP
CFindMAXWrapperEnum
CDeviceRect	Represents a viewport rectangle, but with coordinates in the range [0..1] instead of in pixels
CDialogItemSizeData	Dialog resizing and positioning
CDialogResizer
CDispInfo	This is the display information structure
CDllData	A class for Dlls to use for info that will be sent back to them at load time
CDllDesc	This class models a plug-in DLL
CDMatrix3	Class DPoint3, Matrix Representations of 3D Transformations, Class Quat, Class AngAxis, Structure AffineParts, Class BigMatrix
CDOFParams
CDPoint3	Class DPoint3 Description: This class describes a 3D point using double precision x, y and z coordinates
CDRay
CDropType
CDX9VSConstant
CDxGeneralFunctions
CDynamicMenu	Provides an easy mechanism for plug-ins to produce the menu needed in the ActionItem::GetDynamicMenu() method
CDynamicMenuCallback	When a user makes a selection from a dynamic menu 3ds Max will call DynamicMenuCallback::MenuItemSelected() to process that selection
CEdge
CEdgeBondage
CEdgeClusterList
CEditSSCB	Edit Soft Selection Callback used to control the new Edit Soft Selection Command Mode
CEffectDescriptor	A mini Max class descriptor. This is purely to instantiate multiple objects, and query the Parser ID for the DLL
CEventRouter
CEventUser
►CExitMAXCallback	A callback object that will get called before the program exits
CExitMAXCallback2	A callback object that will get called before the program exits
CExpInterface
CExpr
CExprVar
CExtrudeData
CFace	This class represents a single triangular face
CFaceChange	This class represents the notion of a mesh edit Face Change, which changes the visibility of the face's edges, its hidden state and/or its material ID
CFaceClusterList
CFaceCreate	This class represents the notion of a face create within a MeshDelta
CFaceDataFromPatch
CFaceElementList
CFaceEx	Simple extension to the 3ds Max Face class
CFaceRemap	This class represents the notion of a mesh edit Face Remap, which changes one or more of the vertices a face uses
CFaceSmooth	This class represents the notion of the edit mesh Face Smooth operation
CFBox2
CFilterList	Class FilterList
CFilterManager
►CFlagUser
CMNEdge	An edge used with the MNMesh mesh
CMNFace	The face structure used with the MNMesh mesh
CMNMap	Holds the mapping information for a particular map channel of the MNMesh
CMNMesh	Provided for temporary use by plug-ins, to help with complex topology-based modifications to Meshes
CMNMeshSelectionConverter	When a Mesh object or modifier (such as Editable Mesh, Edit Mesh, or Mesh Select) handles viewport subobject selection, the flow is basically as follows from Editable Mesh
CMNNormalSpec
CMNVert	The vertex class used with the MNMesh mesh
CFlectForces
CFLT_FilterHandler
CFLTInterface
CFontMgrInterface	A class for providing access to required 3ds Max internals
CFPActionDef
CFPEnum
CFPEnum::enum_code
CFPFunctionDef
CFPMacroEmitter
CFPParamDef
CFPParamOptions
CFPParams	This parameters class contains a MaxSDK::Array FPValue's
CFPPropDef
CFPValue
CFrameRange
CGamConvert16
CGamConvert8
CGammaMgr
CGBufData
CGenEdge	A generalized representation of a geometric or texture edge as a pair of vertex indices and face indices
CGenericCallback
CGenericHierarchy
CGenericNamedSelSetList
CGenFace	A generalized representation of a geometric or texture face as an array of vertex indices
CGenSoftSelData	A generic set of parameters defining how soft selection weights are calculated
CGenTri
CGenTriPoints
CGetBoundBoxRequestData
CGetParamDim
CGetParamName
CGetParticleDataRequest
CGetSubObjectRequestData
CGetTimeDataRequest
CHWIndex16Bit	This class is used to help with managing 16 bit hardware index buffer
CHWIndex32Bit	This class is used to help with managing 32 bit hardware index buffer
CHWIndexBuffer	This class is our hw index buffer representation
CHWTupleMesh	This class is a container for vertex and index buffers
CHWVertex	This class is used to help with managing hardware(hw) vertex buffer
CHWVertexBuffer	This is a class that lets you create a hw vertex buffer
►CIHWDrawMesh	This is a wrapper around our low level HW mesh
CHWTupleMeshContainer	This is a container class of our sub meshes
CIHWSubMesh	This is a wrapper class around our HW Mesh
CMeshVertex	This is a class used to track mesh vertices to hw vertices
CGlobalReferenceMaker	This class lets you tap in to ALL reference messages in the entire system
CGlobalReferenceMaker::GlobalReferenceDisableGuard	This class is used to temporarily disable global reference makers
CGMatrix	This class implements a 4x4 matrix object
►CGPort
CGPort2	This class adds extends GPort interface
CGripChangedCallback	A grip changed callback A callback object passed to IGripManager::RegisterGripChangedCallback() The method GripChanged is called every time a different grip or no grip becomes active. */
CGUPManager
CGWFace	A triangular face, which is represented as indexes into a vertex array
CGWinSetup
CHierarchyEntry
CHitByNameDlgCallback
►CHitData	This class is used during sub-object hit testing to identify sub-object components
►CManipHitData	This is a special storage class for hit records that keep track of which manipulator was hit
CSimpleManipHitData
CMNDiagonalHitData	This class is used for hit-testing diagonals of polygons in Editable Poly and Edit Poly
CPatchHitData
CPFHitData	This class is used to identify the particle group and action list the hit particle belongs to
CShapeHitData
CHitListWrapper
CHitLog	This class provides a data structure for keeping a log of hits during sub-object hit-testing
CHitMesh
CHitRecord	This class provides a data structure used during sub-object hit-testing
CHitRegion	Describes the properties of a region used for built-in hit testing of items in the interactive renderer
CHitTestRequestData
CHoldSuspend
CHookPoint
CHSERVER	Used by the Network Rendering API as a handle to a server
CHSVCallback
CI3DXIXRefManager
CIActionItemOverride	Class used to specify action item overrides
CIAdjustMultipleTangents
►CIAssignVertexColors::Options	The options used when calculating the vertex colors
CIAssignVertexColors_R7::Options2	The options used when calculating the vertex colors
CIATSClientAccess	Access to client of ATS Provider
CIATSNotifyCallback	Asset Tracking System Notification Callback Interface
CIATSProvider	ATS Provider Interface
CIBaseGrip::ComboLabel	The label and icon that make up each individual option for Type::eCombo grip item
CIBaseGrip::GripValue	The grip value that's used by the grip item when it's value is retrieved via GetValue or set via SetValue
CIBipedCopy	A copy within a copy collection
CIBipedExport
CIBipFootStep
►CIBipMaster
►CIBipMaster8	Interface into the biped master controller for Max 8
►CIBipMaster9	Interface into the biped master controller for Max 9
►CIBipMaster10	Interface into the biped master controller for Max 10
►CIBipMaster11	Interface into the biped master controller for Max 11
CIBipMaster12	Interface into the biped master controller
CIBrushPreset	The interface to a brush preset object, holding parameters for the PainterInterface and other brush tools
CIBrushPresetContext	Interface to a brush preset context
CIBrushPresetParams	Interface to a set of brush preset parameter values, associated with a particular Brush Preset context
CIBufferable	An Animatable interface for controllers that can be buffered
CICatRegistry
CIChkMtlAPI
CIColorSwatchDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping IColorSwatch pointers
CIContainerUpdateReplacedNode	This class provides an interface to retrieve what new node will replace an existing one during the local edit process
CICopyCollection	A collection of copies
CICUIFrameDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICUIFrame pointers
CICustButtonDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustButton pointers
CICustEditDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustEdit pointers
CICustImageDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustImage pointers
CICustomRenderPresets
CICustSeparatorDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustSeparator pointers
CICustStatusDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustStatus pointers
CICustStatusEditDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustStatusEdit pointers
CICustToolbarDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ICustToolbar pointers
CIDADWindowDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping IDADWindow pointers
CIDaylightControlledLightSystem::DaylightSimulationParams	Set of parameters that may be fed by the daylight system to the controlled light
CIDelegate	An interface class to the delegate
CIDialogMonitorNotification	Dialog Monitor Notification Callback Interface
CIDxSceneManager	A system to manage the current state of the Dx Scene and render passes
CIDxSceneTransformManager	An interface to allow access to scene transforms
CIEffectManager	The Effect Manager is responsible for displaying effect parameters. In 3ds Max this is implemented by the DirectX 9 Material
CIEffectParser	Implemented by Effect Parser
CIEulerControl	IEulerControl is an interface for euler controllers so we can get/set their xyz ordering
►CIExportEntity	Main property access
CIGameConstraint	Simple wrapper class for constraints
CIGameMaterial	Simple wrapper for 3ds Max materials
►CIGameModifier	Simple wrapper for 3ds Max modifiers
CIGameGenMod	A generic Modifier class
CIGameMorpher	An IGame wrapper around the Morph Compound Object and the Morpher Modifier
CIGameSkin	A skin wrapper Class
►CIGameObject	Simple wrapper for 3ds Max objects
CIGameCamera	Simple wrapper for camera objects
CIGameGenObject	A Generic Object for IGame
CIGameIKChain	Simple wrapper for IKChains
CIGameLight	Simple wrapper for light objects
CIGameMesh	Simple wrapper for tri mesh objects
CIGameSpline	Simple wrapper for Splines
CIGameSupportObject	Base class for "support" objects, such as bone, helpers dummies etc.
CIGameXRefObject	An interface for an XRef Object
CIGameTextureMap	Simple wrapper for 3ds Max textures
CIGameUVGen	Class IGameBitmapTex
CIFaceDataChannelsEnumCallBack
CIGameBezierKey	A generic animation key wrapper class
CIGameControl	A simple access class for controllers
CIGameConversionManager	A developer can use this class to define what Coord Systems IGame exports the data in
CIGameErrorCallBack	Error callback
CIGameKey	Main animation key container
CIGameKnot	Simple wrapper for spline knots
CIGameLinearKey	A generic animation key wrapper class
CIGameNode	A simple wrapper for max nodes
CIGameProperty	Main property definition
CIGameRenderedSurface	Class IGameRenderedSurface
CIGameSampleKey	A generic animation key wrapper class
CIGameScene	Main scene access
CIGameSpline3D	A wrapper class for splines
CIGameTCBKey	A generic animation key wrapper class
CIGeometryChecker::OutputVal	The returned output of the checker
CIGizmoBuffer
CIGizmoClass2
CIGizmoClass3
CIGraphNode	Represents a node in the schematic view graph and provides a few methods for querying information about the node
CIGraphObjectManager	Represents an instance of a schematic view window and provides methods for adding nodes and node pointers, refreshing the schematic view, accessing filter bits and updating and controlling the various editors within 3ds Max in ways that are not surfaced in the general interface
CIGraphRef	Represents a node pointer and currently has no methods
CIGuest
CIHost
CIIKChainControl
CIIKControl
►CIImageViewer
CIMaxBitmapViewer
CIImageViewer::PostDisplayCallback
CIImageViewer::PreEventHandlerCallback
►CIIndirectReferenceMaker	The interface for an object to specify the ReferenceTargets it is dependent on, but doesn't hold a reference to (i.e., indirect references)
CIIndirectRefTargContainer	The interface for a container of indirect references
►CIKClipObject
CStdIKClipObject
CIKDeriv
CIKEnumCallback
►CIKey
CIBezFloatKey
CIBezPoint2Key
CIBezPoint3Key
CIBezPoint4Key
CIBezQuatKey
CIBezScaleKey
CIBipedFSKey
►CIBipedKey
CIBipedBodyKey
CIBipedHeadKey
CIBipedHorzKey
CIBipedPropKey
CIBipedTurnKey
CIBipedVertKey
CIBoolFloatKey
CILinFloatKey
CILinPoint3Key
CILinRotKey
CILinScaleKey
►CITCBKey
CITCBFloatKey
CITCBPoint3Key
CITCBPoint4Key
CITCBRotKey
CITCBScaleKey
►CIKeyControl
CIBoolCntrl
CIKeyControl2	Extend IKeyControl to include interfaces to IKeyProperty
►CIKeyProperty	Interface to the Key Property
►CIIKKeyProp	Interface to the IK Key Property
CISetIKKeyProp	This is a helper class
CDofSet
CIterJoint
CIterJoint::JointAxes
CLink
CLinkChain
CRootLink
CZeroPlaneMap
CILightingData	Access Lighting data from 3ds Max lights
CILightingUnits::LightDispInfo	Encapsulates the information related to a unit system
CILightManager	A basic light container
CILinkTMCtrl
►CILockedTrack	An interface to a track that can get locked
►CILockedTrackImp	This class provides an implementation of ILockedTrack base class, including a local variable that's used for the persisting the lock
CLockableControl
CLockableStdControl
CILockedTrackClient	An interface to an object who is a client that has subanims that may get locked
CImageFilter
CImageFilterInfo
CIMCapManager
►CIMenuElement
►CIMenu
CIPopupMenu
►CIMenuItem	This abstract class represents an interface for a menu item Methods that are marked as internal should not be used
CIMenuItemExtension	Extends the IMenuItem interface
CIMenuGlobalContext
CIMenuLocalContext
►CIMenuSettings
CIQuadMenuSettings
CIMenuTimer
CIMeshSelect
CIMeshSelectData
CIMeshWrapper
CIMetaDataManager::ParamDescriptor	A description for a parameter to be used in a meta-data, and its UI in an eventual rollout
►CIMixer
CIMixer8	An interface to the new functionality for max 8 for the mixer
CIMixSlave	INTERNAL USE
CIMoFlow
CImpInterface
CImpNode
►CIMultiMenu
CIMenuBar
CIQuadMenu
►CIMXclip
CIMXclip8	An interface to the new functionality for max 8 for clips in the mixer
►CIMXtrack
CIMXtrack8	An interface to the new functionality for max 8 for tracks in the mixer
►CIMXtrackgroup
CIMXtrackgroup8	An interface to the new functionality for max 8 for trackgroups in the mixer
►CInitJointData
►CInitJointData2
CInitJointData3	class InitJointData3 : public InitJointData2
CInst
CInterface::SuspendSceneRedrawGuard	Scene redraw guard class
CInterface_ID
►CInterfaceNotifyCallback
CFPInterfaceValue
CFPMixinInterfaceValue
CFPStaticMethodInterfaceValue
►CInterfaceServer
►CAnimatable
►CReferenceMaker	A scene entity that owns other scene entities and listens to messages from them
CIMCParamDlg
CIStdDualVS
►CReferenceTarget	A scene entity that is being owned and listened to by other scene entities
CBaseBehavior	All behaviors must inherit from this base class
►CBaseObject	This is the base class for objects and modifiers
►CModifier	This is the class from which you may derive Object Space and Space Warp (World Space) Modifier plug-ins
CISplineIKControl
CIUnwrapMod
COSModifier	This is a base class developers creating object space modifiers may derives their plug-ins from
►CSimpleMod	Base class for parameter block 1 (PB1) based object space modifiers
CSimpleMod2	Base class for parameter block 2 (PB2) based object space modifiers
►CSimpleWSMMod
CSimpleOSMToWSMMod
►CSimpleWSMMod2
CSimpleOSMToWSMMod2
CWSModifier	This is a base class for creating world space modifiers
►CObject	The object class is the base class for all objects
►CCameraObject	This is a base class from which camera plug-ins may be derived
►CGenCamera
CIPhysicalCamera	Access to the properties of the Physical Camera object
►CGeomObject	This is the base class for the creation of Geometric Object plug-ins
CIBoolObject
►CParticleObject	This is the base class for creating particle system plug-ins
CSimpleParticle
CPatchObject
CPolyObject
►CShapeObject	ShapeObjects are open or closed hierarchical shapes made up of one or more pieces
CLinearShape
CSimpleShape
CSimpleSpline
CSplineShape
►CSimpleObject
CDynamHelperObject
CGenBoxObject
CGenCylinder
CGenSphere
CSimpleObject2
CSimplePolyObject	This is a base class for creating procedural objects compatible with Editable Poly
CTriObject
►CHelperObject	This is used as a base class to create helper object plug-ins
CConstObject	This is a base class used to create construction grid objects
CDummyObject
►CGizmoObject
CBoxGizmoObject
CCylGizmoObject
CSphereGizmoObject
►CManipulator
CSimpleManipulator
►CPFSimpleAction
CPFSimpleOperator
CPFSimpleTest
CIDerivedObject
►CIXRefObject	Legacy interface for xref objects
CIXRefObject8	Class representing Xref objects
►CLightObject	This is the base class from which plug-in lights may be derived
►CGenLight
►CLightscapeLight	Common Photometric light
CLightscapeLight2	Extension to Photometric light This interface extends class LightscapeLight with new functionality in 3ds Max 2016
CISunPositioner	Access to functionality and properties of the Sun Positioner object
►CWSMObject	This class is a base class used to derived the helper object for a space warp modifier (WSM Modifier)
►CSimpleWSMObject
CSimpleOSMToWSMObject
►CSimpleWSMObject2
CDynamModObject
CBevelProfileCurveInterface	This is the interface to the actual bevel profile curve
►CControl
CIKSlaveControl
CILinkCtrl
CIListControl	IListControl provides API access to list control functionality
CILookAtConstRotation
CILookatControl
CIMCControl
CIOrientConstRotation
CIPathPosition
CIPosConstPosition
CISurfPosition
CIXRefCtrl	Interface implemented by the XRef controller
CLockableControl
CMasterPointControl
CMorphControl
►CStdControl
►CIBaseScriptControl
CIBaseScriptControl8
CIBaseWireControl
CIBoolCntrl
CINoiseControl
CLockableStdControl
CCreaseSetManager
►CCustAttrib
CMSCustAttrib
CDADBitmapCarrier
CEaseCurveList
CGizmoClass
CIADTCategory
CIADTObjMgr
CIADTStyle
►CICollision
CCollisionMesh
CCollisionPlane
CCollisionSphere
CICurve
CICurveCtl
CICustAttribContainer
CIKMasterControl
►CILayer	Interface to the layers functionality
CILayerEx	Extended interface to the layers functionality. Added for 3dsMax 2016
►CILayerManager	This class is an interface to the layer manager
CILayerManagerEx	This class is an extended interface to the layer manager
CIMultiPassCameraEffect	The multipass camera effect allows modification of viewpoints and view directions or time for each pass of a multipass rendering
►CINode
CINodeTransformed
CIParamBlock
CIParamBlock2
CIProjectionModType
►CIRefTargContainer	Container that handles references to ReferenceTargets
CIIndirectRefTargContainer	The interface for a container of indirect references
CITrackViewNode
CMAXWrapper
CMCDeviceBinding
►CMtlBase
►CMtl
►CIXRefMaterial	Class representing xref materials
CIXRefMaterial18	Class extends IXRefMaterial interface with override material feature
CMultiMtl
►CStdMat
CStdMat2
►CTexmap
CBitmapTex
CIEnvironmentContainer	Aggregates the properties related to environment and background mapping
►CMultiTex
CGradTex
CIMultiTile
CStdCubic
CStdMirror
CTex3D
►CTextureOutput
CStdTexoutGen
►CUVGen
CStdUVGen
►CXYZGen
CStdXYZGen
CMtlBaseLib
CMtlLib
CMultCurveList
►CNoteTrack
CDefNoteTrack
CRefMgr< T >	Manages a variable number of references
►CRenderer	This is the base class for any renderer plugin
►CIScanRenderer	This class provides an interface into the standard 3ds Max scanline renderer
CIScanRenderer2
CUnifiedRenderer	Unifies functionality for, both, interactive (ActiveShade) and offline (Production) rendering
CShadowType
CSoundObj
►CSpecialFX
►CAtmospheric
CIAtmosphericContainer	This is container, anchor point for a set of atmospherics
CIXRefAtmospheric	Class representing xref atmospherics
CStdFog
►CBaseShader	One of the base classes for the creation of the Shaders, which plug-in to the Standard material[?]
CShader	Used by developers to create Shader plug-ins
►CEffect
CEffect8	Extension to class Effect, new to 3ds max 8
CIRenderEffectsMgr	This class represents the interface for the Render Effects Manager
CFilterKernel
►CIRenderElement
►CMaxRenderElement
►CMaxBakeElement
►CMaxBakeElement8	Extention to MaxBakeElement in 3ds Max 8
CMaxBakeElement10	Extention to MaxBakeElement8 in 3ds Max 10
CRadiosityEffect
CSampler
►CToneOperator	This is the base class for plugins which perform tone mapping operations in 3ds Max
CIPhysicalCameraToneOperator	Access to the properties of the Physical Camera Exposure Control
CTexmapContainer
CUserType
CRefMgrAddDeleteRestore< T >	Restore class for RefTarget class Note, Do not use this class as this is used by the internal system only
CRefTargMonitorRefMaker	Defines a class for monitoring a ReferenceTarget
CRolloutControl
►CSingleRefMaker	Reference Maker to single entity
CSingleWeakRefMaker	Utility base class for a ReferenceMaker with a single target that does not share ownership of it's ReferenceTarget
CSingleRefMakerPatchMtl
CSingleRefMakerPatchNode
CSingleRefMakerSplineMtl
CSingleRefMakerSplineNode
►CBaseInterface
CBezierShapeInterface_Ex41	class BezierShapeInterface_Ex41 : public BaseInterface
CBitmapIOLayer
CBitmapIOMetaData	Extends BitmapIO with additional information for automatic gamma correction etc
►CCreaseSetContainer
CCreaseSetManager
CEffect8	Extension to class Effect, new to 3ds max 8
►CFPInterface
CCollisionOps
►CFPInterfaceDesc
CExposureMaterialControlDesc	This implementation of ClassDesc is to be used to implement the ExposureMaterialControl interface
►CFPStaticInterface
CBitmapLayerUtl
CIActionItemOverrideManager	The interface for managing action item overrides
CIActionManager	Manages a set of ActionTables, ActionCallbacks and ActionContext
CIADTObjMgr
CIAnalyzer	Interface for perfoming workbench analysis functions
CIAnimLayerControlManager	The interface to the functionality for animation layers
CIAssemblyMgr
►CIAssignVertexColors	The IAssignVertexColors is a static interface to the Assign Vertex Color utility
CIAssignVertexColors_R7	This class extends IAssignVertexColors to include more options
CIATSCustomDeps	Interface to Asset Tracking Custom Dependencies
CIATSMax	Interface to Asset Tracking System
CIAutodesk360	Interface class for exposing methods associated with Autodesk 360
CIAutoTangentMan	Manages controller auto-tangent related options
CIBatchRenderManager	This class is the manager of the batch rendering feature
CIBitmapIO_Bmp	This class represents the interface for the Bitmap IO BMP format
CIBitmapIO_Jpeg
CIBitmapIO_Png
CIBitmapIO_Rgb
CIBitmapIO_RLA	Expands upon the previous IBitmapIO classes
CIBitmapIO_Tga
CIBitmapPager
CIBitmapProxyManager	Bitmap Proxy Manager Function-Published Interface
CIBlockMgr
CIBrowserMgr
CIBrushPresetMgr	Interface to the brush preset manager
CIColorCorrectionMgr	This interface manages the correction that can be made to the colors
CIColorManager
CICommandPanel
CIContainerManager	The interface for global container functionality
CIContainerPreferences	This interface provides access to the container preferences
CICustAttribCollapseManager	This interface provides access for setting and querying the state of flag that defines whether a Custom Attribute should survive a stack collapse
CICustomControlsOptions	Class used to handle some custom controls options
CIDaylightSystemFactory	Factory for daylight system objects
CIDaylightSystemFactory2	Factory for daylight system objects
CIDialogMonitor	Interface to Dialog Monitor System
CIDragAndDropMgr	Manager class for Drag and Drop The Drag and Drop system is managed through a Core FP interface (DND_MGR_INTERFACE), defined by this class
CIDXShaderManagerInterface	An Interface that provides access to the actual manager
CIFileResolutionManager
CIFilter	Interface for perfoming workbench filter functions This class peforms workbench functions related to the filtering of fcurves
CIFixer	Interface for perfoming workbench fixer functions
CIFPLayerManager
CIFrameTagManager
CIGeometryCheckerManager	The interface to the geometry checker manager
►CIGlobalDXDisplayManager	This interface provides the user control over how the viewport shaders are displayed in the viewport
CIGlobalDXDisplayManager2	Provides methods to turn on DirectX based Scene effects
CIGripManager	The interface to the functionality for using the Grip Manager
CIHeightManager	This interface gives access to the HeightManager
CIICEFlowFileBirthSetup	Factory for the Particle Flow creation from a OneClick plugin
CIICEFlowParticleFactory	Factory interface for the Particle Flow creation from a plugin
CIICEFlowShapeControl	Shape Control interface to change the shape of a given particle system
CIInstanceMgr	Manages instances of objects, modifiers, transformation controllers Use this interface to work with object instances in a Max scene
CIKChainActions
►CIKCmdOps
CIKCmdOpsEx	This interface extends interface IKCmdOps by providing access to notification suspension for the IK system
CILightingUnits	Provides access to the lighting unit system for converting and displaying luminance and illuminance values
►CILoadSaveAnimation	The interface to the functionality for loading saving XML animation files
CILoadSaveAnimation10	An extension to ILoadSaveAnimation that exposes additional functionality
CILockedTracksMan	Locked Track Manager This class provides an interface for managing and setting locks on acceptable tracks
CIMainThreadTaskManager	This class allows a plugin to post a Task to be executed on 3DS Max main thread
CIManipulatorMgr
CIMBOps	The interface for Image Motion Blur
►CIMenuManager	Used for managing all menus To get an interface for calling the methods of this class use Interface::GetMenuManager()
CIMenuManagerExtension	Extension class for IMenuManager, can be accessed by calling GetCOREInterface()->GetMenuManager() and downcasting to this interface
CIMetaDataManager	The interface for creating, adding, removing and keeping track of meta-data on max Animatables
CIMSZipMgr
CIMtlBrowserFilter_Manager
CIMtlEditInterface
CIMtlRender_Compatibility_MtlBase
►CIMtlRender_Compatibility_Renderer
CUnifiedRenderer	Unifies functionality for, both, interactive (ActiveShade) and offline (Production) rendering
CIMXSDebugger
CINamedSelectionSetManager	The Named Selection Sets management class
►CINaturalLightClass	class INaturalLightClass: public BaseInterface
CNaturalLightClassBaseImp
CINetCreateHelpers
►CInterface
►CIObjParam
►CIObjCreate
►CInterface7	This class extends Max's previous version of core interface (class Interface) "7" is the major version number of Max that exposes this interface
►CInterface8	The interface class for max version 8
►CInterface9	The interface class for max version 9
►CInterface10	Extends Interface9 Client code should retrieve this interface using GetCOREInterface10
►CInterface11	Extends Interface10 Client code should retrieve this interface using GetCOREInterface11
►CInterface12	Extends Interface11 Client code should retrieve this interface using GetCOREInterface12
►CInterface13	Extends Interface12 Client code should retrieve this interface using GetCOREInterface13
►CInterface14	Extends Interface13 Client code should retrieve this interface using GetCOREInterface14
►CInterface15	Extends Interface14 Client code should retrieve this interface using GetCOREInterface15
CInterface16	Extends Interface15 Client code should retrieve this interface using GetCOREInterface16
CINVIDIARenderersHelper
CIObjXRefManager	Legacy interface for managing object xrefs
►CIObjXRefManager8	Class for managing object xrefs
CIObjXRefManager18	This interface extends IObjXRefManager8 interface
CIParamPubMgr
CIParamWireMgr
CIParserLoader	A core interface used to store parser DLLs found in the system
►CIPathConfigMgr	Provides access to application path configuration functionality
CIPathConfigMgrEx	Provides extended access to application path configuration functionality
CIPerezAllWeather	Interface for accessing functionality that exists in the Perez All Weather Model
CIProjectionIntersectorMgr
CIProjectionRenderMgr
CIQuadMenuSettings
CIRadiosityPreferences
CIRefHierarchy
CIRollupSettings
CISceneStateManager	This class is the public interface to the scene state feature
CISimpleFaceDataManager	The function-published interface for managing SimpleFaceData channels on an object
CIStatusPanel
CITabDialogManager
CITimeSlider	This class represents the interface for the time slider
CITrackViewArray
CIUtilityPanel	class IUtilityPanel : public FPStaticInterface
CIViewPanelManager	In 3ds Max 2013, 3ds Max introduces the tabbed view panels
CIViewportButtonManager	A manager to control the usage of the viewport buttons
►CIViewportShadingMgr	Viewport manager to control general illumination, including shadow support in the viewport
CIViewportShadingMgr2	Extends class IViewportShadingMgr
CIVisualMSMgr
►CIWorkBench	The interface to the CS Workbench
CIWorkBench2	Additional interface for the CS Workbench
CIWorkingPivot	The interface to the functionality for using the Working Pivot
CIAssetManager
CIMouseConfigManager	A core interface for accessing properties of the customized mode introduced in 3ds Max 2013
CIDisplayManager	A core interface for accessing properties of the graphics library introduced in 3ds Max 2012
CIShaderManagerCreator	Factory class for IShaderManager objects
CIHelpSystem	This interface provides access to the 3ds Max Help system
CIPhysicalSunSky::IShaderGenerator	Provides facilities to initialize the shading parameters of the Physical Sun & Sky plugin
CIPopulate	This is the interface class to Populate
CRadiosityInterface
CToneOperatorInterface
CTrackSelectionSetMgr
CValueConverter
►CFPMixinInterface
CActionItem	Represents an operation contained in an ActionTabls
CActionTable	A table of action items that can be used by plug-ins to export tables of action items that can be used by the UI to attach to keyboard shortcuts, assigned to toolbar buttons, and add to menus
CBitmapTex
CCheckAbortCallback
►CEPoly
►CEPoly13	This new class extends EPoly with new functionality, in particular the ability for epoly to support manipulate grips
CEPoly18	This new class extends EPoly with new functionality, for new hard/smooth edge workflow
►CEPolyMod	This class is the published interface for Edit Poly modifiers
►CEPolyMod13	This new class extends EPolyMode, in particular adds a more efficient way for setting several vertex positions, and the ability for EPolyMod to support manipulate grips
CEPolyMod18	This new class for Phoenix extends EPolyMod for altering vertex and edge Crease/Weight/etc. values
►CExposureMaterialControl	This is the inteface class to implement in order to support exposure controls
CAddExposureMaterialControl< B >	This class implements a small hack to get around issues in the VS2005 compiler
CGizmoShape
CIADTCategory
CIADTStyle
CIAnimTrack	Interface of a parameter track object, a member of a track set
CIAssembly	This interface class allows for setting and retrieving assembly membership information to or from nodes
CIBaseWireControl
CIBatchRenderView	This class represent one entry in the list of batch render views
CIBlobMesh	Access to the UI controls of the Blob Mesh object; adding and removing nodes programatically, and initiating pick mode
CIBlockRefComponent
CIBrowser
►CIChannelContainer
CIParticleContainer
►CIContainerObject	Container Interface
►CIContainerObject13	IContainerObject13 Interface
CIContainerObject16	IContainerObject16 Interface
►CIDaylightSystem	Use this interface to access the sun and sky components of a daylight system created by IDaylightSystemFactory
►CIDaylightSystem2	Extends IDaylightSystem with new functionality This interface can be obtained when the daylight system is created
CIDaylightSystem3	Extends IDaylightSystem2 with new functionality This interface can only be obtained from an already existent daylight system, from the base object of the daylight assembly:
►CIDxMaterial	An interface class to manage access to various parameters used by DirectX effects
►CIDxMaterial2
CIDxMaterial3
CIEditNormalsMod
CIJiggle
CILagMod
CILayerControl	ILayerControl provides API access to layer control functionality
CILayerDisplayProperties
CILayerProperties
CILimitControl	Base Limit Controller Interface
CILinkCtrl
CIListControl	IListControl provides API access to list control functionality
CILookAtConstRotation
CILookatControl_Extension
CILuminaire
CIMenu
CIMenuItem	This abstract class represents an interface for a menu item Methods that are marked as internal should not be used
CIMeshDeformPWMod	IMeshDeformPWMod is the interface into the Skin Wrap(Mesh) modifier
CIMorphByBone
CIMXSParticleContainer
CINode
CINodeBakeProjProperties
CINodeBakeProperties
CINodeDisplayProperties	Class INodeDisplayProperties : public FPMixinInterface
CINodeExposure	Class INodeExposure: public FPMixinInterface
►CINodeGIProperties	Class INodeGIProperties : public FPMixinInterface
CINodeGIProperties2	This interace accesses the adaptive subdivision properties
CINodeLayerProperties	Class INodeLayerProperties : public FPMixinInterface
CINodeMentalRayProperties	Extension to INode for accessing mental ray properties
CINodeMonitor	The interface for working with NodeMonitor class
CINodeShadingProperties	A node based interface to support new Viewport Rendering features
CINodeTransformMonitor	The interface for working with NodeTransformMonitor class
►CIObjXRefRecord	Class for managing an object xref record
CIObjXRefRecord16	This interface extends IObjXRefRecord interface
CIOrientConstRotation
CIParticleCache
CIParticleChannel
►CIParticleChannelAmountR
CIParticleContainer
►CIParticleChannelAmountW
CIParticleContainer
CIParticleChannelAngAxisR
CIParticleChannelAngAxisW
CIParticleChannelBoolR
CIParticleChannelBoolW
CIParticleChannelExt
CIParticleChannelExt2
CIParticleChannelFloatR
CIParticleChannelFloatW
CIParticleChannelIDR
CIParticleChannelIDW
CIParticleChannelINodeHandleR
CIParticleChannelINodeHandleW
CIParticleChannelINodeR
CIParticleChannelINodeW
CIParticleChannelIntR
CIParticleChannelIntW
CIParticleChannelMapR
CIParticleChannelMapW
CIParticleChannelMatrix3R
CIParticleChannelMatrix3W
CIParticleChannelMeshMapR
CIParticleChannelMeshMapW
CIParticleChannelMeshR
CIParticleChannelMeshW
CIParticleChannelNewR
CIParticleChannelNewW
CIParticleChannelPoint3R
CIParticleChannelPoint3W
CIParticleChannelPTVR
CIParticleChannelPTVW
CIParticleChannelQuatR
CIParticleChannelQuatW
CIParticleChannelTabTVFaceR
CIParticleChannelTabTVFaceW
CIParticleChannelTabUVVertR
CIParticleChannelTabUVVertW
CIParticleChannelTrueFalseIterator
CIParticleChannelTrueFalseIterator2
CIParticleChannelVoidR
CIParticleChannelVoidW
CIParticleGroup
CIParticleGroupExt
CIParticleObjectExt
CIPatchDeformPWMod
CIPathPosition
►CIPFAction
CPFSimpleAction
CIPFActionExt
CIPFActionList
CIPFActionListMaterialHolder
CIPFActionListPool
CIPFActionListSet
►CIPFActionState
CPFSimpleActionState
CIPFArrow
CIPFIntegrator
►CIPFOperator
CPFSimpleOperator
CIPFOperatorPhysXWorld
CIPFRender
CIPFSystem
CIPFSystemPool
►CIPFTest
CPFSimpleTest
CIPFViewport
CIPointCache
CIPointCacheWSM
CIPosConstPosition
CIProjectionMod
CIProjectionMod10
►CIPViewItem
CPFSimpleAction
CIPViewItemCreator
CIPViewManager
CIQuadMenu
CIRefTargMonitorClass	The interface for working with RefTargMonitor class
CIRenderElementMgr
CIRotWindup
CIScanRenderer2
CIScriptCtrl
CISimpleFaceDataChannel	The function-published interface for a simple per-face data channel
►CISimpleManipulator
CSimpleManipulator
CISkinPose
CISplineIKControl
CITrackBar
►CITreeViewOps
CITreeView
CITreeViewUI
CIUnwrapMod
CIUnwrapMod2
CIUnwrapMod3	This class is only available in Max 6.0 and higher
CIUnwrapMod4
►CIVertexPaint	The IVertexPaint interface provides a way to set the vertex colors held in a VertexPaint modifier
CIVertexPaint_R7
►CIViewportShaderManager	An Interface class to access the Viewport Manager
►CIViewportShaderManager2	A new interface for 3dsmax 7
CIViewportShaderManager3	A new interface for 3dsmax 10
CIVisualMSCallback
CIVisualMSForm
CIVisualMSItem
CIXRefAtmospheric	Class representing xref atmospherics
CIXRefCtrl	Interface implemented by the XRef controller
CIXRefItem	Generic interface that represents an xrefed scene entity
CIXRefMaterial	Class representing xref materials
CIXRefObject8	Class representing Xref objects
CIXRefProxy	Class for working with the proxy aspect of an xref scene entity
CAssetUser
CIViewportViewSetting	Viewport Setting For The Nitrous Graphics Viewport
CIPointCloud	The interface for interacting with point cloud objects
CIPopulateFlow	IPopulateFlow is the interface class to Populate flow objects
CNodeAndAnims	A class that holds a node and a list of anims under that node that can be used for loading,saving, mapping animation, or putting specific tracks into the mixer
CPlane
CRadiosityMesh
CRealWorldMapSizeInterface	The commong mix-in interface for setting realWorldMapSize properties on objects and modifiers
CXMLAnimTreeEntry	XMLAnimTreeEntry class that's used for storing a controller track
CXMLAnimTreeEntryList	The list of XMLAnimTreeEntry tracks, that will then be loaded onto, or saved out, or put into the mixer
CIMaterialBrowserEntryInfo	This interface allows materials and textures to customize their appearance in the Material Browser
CIActionManager10	A mixin-interface extension to IActionManager which allows a client to dispatch a Message back to the application if it is not handled by the focused control
CIActionOptions	This interface should be implemented if an action item (ActionItem) supports an alternate options command
CIAreaShadowType
CIAttachCtrl	IAttachCtrl is an interface for getting/setting properties on the Attach controller
►CIBaseGrip	A pure virtual interface for implementing grips
CIBaseGrip2	A virtual interface to extend IBaseGrip
CIColorSwatchRenamer	class IColorSwatchRenamer
CID3D9GraphicsWindow
CID3DHWMeshCacheManager
CIDaylightControlledLightSystem
CIDX9PixelShader
CIDX9VertexShader
►CIDXDataBridge	Viewport DXEffect interface
CIDX9DataBridge
CIEffectFile	Implemented by a plugin, typically a material, to provide access to the underlying shader code
CIEmissionColor
CIFaceDataMgr
CIGeometryChecker	Base Class For Geometry Checkers
►CIHardwareMaterial
►CIHardwareMaterial2	Extension of IHardwareMaterial Interface
CIHardwareMaterial3	Extension of IHardwareMaterial2 Interface
CIHardwareMesh
CIHardwareMNMesh
►CIHardwareShader
►CIHardwareRenderer
CIHardwareRendererST
CIIlluminationComponents	This is the interface to use illumination by components this may be supported by a light object returned by lightObjDesc::GetInterface( IID_IIlluminationComponents );
►CIIKGoal
CIHIIKGoal
►CISplineIKGoal
CISplineIKGoal2	Extension to ISplineIKGoal, the interface of a spline IK goal object
CILockedContainerUpdate	This class provides an interface for classes that may need to augment the new container update process that was introduced in 3ds Max 2011
CIMaterial
CIMaterialViewportShading	A new interface for 3ds Max 2008
CiMNMESH_GPU_Display
CIMNMeshUtilities10	Extends the MNMeshUtilities class, adding new functionality applied on a MNMesh
CIMNMeshUtilities13	Extends the MNMeshUtilities class, adding new functionality applied on a MNMesh
CIMNMeshUtilities8	IMNMeshUtilities8 extends the MNMeshUtilities class, adding new functionality applied on a MNMesh
CIMNTempData10	Interface for changes made to MNTempData in version 9.5
CIMtlBrowserFilter
CINewSubTexmapNotification
CINodeValidity	This interface provides access to the node's geometry pipeline, transform and whole world state validity intervals
►CIOsnapManager
CIOsnapManager7
CIParamBlock2PostLoadInfo	Informational class about ParamBlock2 objects loaded from file
CIPFViewportExtension2	This interface is used for extending IPFViewport with an additional method UpdateDisplay()
►CIPipelineClient
CMeshNormalSpec	This class is an interface used to store user-specified normals (such as those created in the Edit Normals modifier)
CMNNormalSpec
CIProjection_WorkingModelInfo
CIProjectionModData
CIPublishedCustAttrib	Any CustAttrib which wants to support being published should implement this interface
CIRadiosityEffectExtension
CIRadiosityRenderParameters
CIRenderElementRequirements
CIRTShaderParameterBinding	Interface for setting parameters in a compiled effect file
CISceneCallbackPriority	An interface to set priority to ViewportDisplayCallback's
►CISceneEventCallback
CINodeEventCallback
CISceneEventManager
CISceneTraversal
CIShadeContextExtension8	This class is an API extension for the ShadeContext class
CISkyLight	Class ISkyLight : public BaseInterface
CISpecularCompositeShader	class ISpecularCompositeShader : public BaseInterface
CISplineIKControl2
CISubMtlMap_BrowserFilter
CISunLight	Class ISunLight : public BaseInterface
CITabDialogFilter
►CITabDialogObject
CUnifiedRenderer	Unifies functionality for, both, interactive (ActiveShade) and offline (Production) rendering
CITabDialogPluginTab
CITabDialogProc
CITabPage
CITimeBasedConverter
CIToneOperatorExtension
CITrackBarFilterManager
CIViewPanel	Many viewpanel related methods of CORE interface only work on the active tabbed view panel
CIXTCAccess	Provides an interface to access Extension Channels
CLightscapeLight::AreaLightCustAttrib	Area Lights sampling custom attribute
CIHLSLMaterialTranslator	Facilitates translation of material parameter values to their shaders representation
CIMeshDisplay2	Use this interface to query the per node related render items from a mesh or mnesh
CIObjectDisplay2	To give object plugins better control of display, now object plugins can expose IObjectDisplay2 interface
CIParameterTranslator	Facilitates translation of material and texture map parameter values to their shaders representation
CIShaderManager	Represents the programmable shader associated with a material or texture map plug-in
►CISimpleMaterial	ISimpleMaterial provides any material or texture plugin the ability to display itself in the new Viewport Display system in 3ds Max 2012
CISimpleMaterialExt	ISimpleMaterialExt extends ISimpleMaterial to support more textures
CITextureDisplay	This interface enables material and texture map plugins to display textures in the new viewport display system in 3ds Max 2012
CIPopulateSeat	IPopulateSeat is the interface class to Populate seat objects
CTexmapThreadSafe	TexmapThreadSafe provides any texture plugin with thread safe support information in 3ds Max 2015
CMeshSelectionConverter
CNodeDisplayCallbackEx
►COpenSubdivParameters	If a renderer or other plugin wants to determine if an object is using Pixar's OpenSubdiv to perform subdivision, it can use the GetInterface method to query the INode for the OSD_PARAMETER_INTERFACE interface
COSDModifierInterface	If a feature needs to determine and/or set the OpenSubdiv modifier's parameters, it can use the GetInterface method to query the Modifier for the OSD_MODIFIER_INTERFACE interface
CPBRescaleParamAccessor
CSkyLightEval	Class SkyLightEval : public BaseInterface
►CBaseInterfaceServer
►CActionCallback	3ds Max uses the ExecuteAction() method of an instance of this class when an ActionItem is executed
CTrackViewActionCallback
CBezierShape	Defines a basic bezier shape object
CBitmap	Class for image input and output
CBitmapIO	Base class for image IO plugins
►CBitmapStorage
CBitmapStorageHDR
CBitmapStorageLDR
CCamera	Represents the projection matrix and common properties of a perspective or orthographic camera
CCUIFrameMgr
CFrameRendParams	This is passed to the renderer on every frame
CHold
CIKSolver
CIlluminateComponents	Provides the components of the Illuminate function to Shaders, Materials and Render Elements
CIllumParams
►CIObject
CIParticleContainer
CITreeView
CAssetUser
CPFSimpleActionState
CLight	Describes lights used in the interactive renderer
CMacroEntry	This class provides access to a single macro entry
CMacroRecorder	Provides various methods to emit pieces of script to the Macro Recorder
CManipulatorGizmo
CMaterial	The main material class definition
►CICustomRenderItem	This class is used to customize the behavior of a render item
CIGPUDisplayRenderItem
►CIConsolidationRenderItem	This class defines a consolidation render item, which is used to improve rendering performance by batching similar render items together
CMarkerConsolidationItem	This class collects all marker items(both immediate and non-immediate), hardware build vertex buffer and index buffer in Realize() function and render them in Display() function
►CMeshEdgeConsolidationItemDX11	This class collects mesh edge render items and build hardware buffers for them
CMeshEdgeConsolidationItemDX9
CSplineConsolidationItem	This class collects all spline items(both immediate and non-immediate), hardware build vertex buffer and index buffer in Realize() function and render them in Display() function
CMarkerRenderItem	Base class for marker render items
CMeshEdgeRenderItem	This class is designed for small meshes that only renders edge element
CSplineRenderItem	Base class for spline render items
►CIRenderGeometry	IRenderGeometry is a presentation of geometry
CSimpleRenderGeometry	SimpleRenderGeometry is a simple implementation of IRenderGeometry
CMesh	Provided for use by plug-ins and is used by the system
CMeshDelta
CMeshTempData
CMNMesh	Provided for temporary use by plug-ins, to help with complex topology-based modifications to Meshes
CMNTempData	Used for caching face and edge clusters, vertex normals, and other derived data about an MNMesh
CModContext	The ModContext stores information about the space the modifier was applied in, and allows the modifier to store data is needs for its operation
►CMouseCallBack	Allows the developer to capture and process the mouse events entered by the user
CDataEntryMouseProc
CEP_BevelMouseProc
CEP_BindMouseProc
CEP_CopyTangentMouseProc
CEP_CreatePatchMouseProc
CEP_CreateVertMouseProc
CEP_ExtrudeMouseProc
CEP_NormalFlipMouseProc
CEP_PasteTangentMouseProc
CEP_VertWeldMouseProc
CMouseToolCallBack
►CSelectionProcessor
►CGenControlSelectionProcessor
CSubControlSelectionProcessor
►CGenModSelectionProcessor
CEP_BevelSelectionProcessor
CEP_ExtrudeSelectionProcessor
CSSChamferSelectionProcessor
CSSFilletSelectionProcessor
CSSOutlineSelectionProcessor
CSubModSelectionProcessor
CSSBindMouseProc
CSSBooleanMouseProc
CSSChamferMouseProc
CSSCopyTangentMouseProc
CSSCreateLineMouseProc
CSSCrossInsertMouseProc
CSSCrossSectionMouseProc
CSSExtendMouseProc
CSSFilletMouseProc
CSSOutlineMouseProc
CSSPasteTangentMouseProc
CSSRefineConnectMouseProc
CSSSegBreakMouseProc
CSSSegRefineMouseProc
CSSTrimMouseProc
CSSVertConnectMouseProc
CSSVertInsertMouseProc
►CTransformCtrlApparatus
CMoveCtrlApparatus
CRotateCtrlApparatus
CScaleCtrlApparatus
CSelectCtrlApparatus
►CTransformModBox
CMoveModBox
CRotateModBox
CScaleModBox
CSelectModBox
CMouseManager
►COsnapHit
CTypedHit
CParamBlockDesc2
CPatch
CPatchMesh
CRenderGlobalContext
CShadeOutput
CSpringSys
CSSSpring
CSubRendParams	This structure contains information on rendering for Mirror and Automatic Cubic materials
CTextureInfo
CViewParams	Describes the properties of a view that is being rendered
CBevelProfileUtilityInterface	This object is a system interface which allows plugins to work with Bevel Profiles
CBitmapManager
CCollisionObject	A collision object can be applied to a particle system by a Space Warp
CColorPicker
CColPick
►CDADMgr
CMtlDADMgr
CTexDADMgr
►CDisplayFilterCallback
CMSDisplayFilterCallback
CDragAndDropHandler	The base class from which specialized drag-and-drop handlers should be derived
►CDropClipFormat
CDropScriptClipFmt
CIDropPackageClipFmt
CVIZableClipFmt
CExclList
CForceField	A Space Warp modifier usually uses an instance of this class and implements the Force() method
CFPValidator
CGBuffer
CGBufReader
CGBufWriter
►CGeomPipelineEnumProc
CNotifyCollapseEnumProc
CNotifyCollapseMaintainCustAttribEnumProc	Class used by EnumGeomPipeline to notify the pipeline of a collapse as well as maintaing the Custom Attributes. (Obsolete)
CNotifyCollapseMaintainCustAttribEnumProc2	Class used by EnumGeomPipeline to notify the pipeline of a collapse as well as maintaing the Custom Attributes
CGraphicsWindow
CGUP
CGUPHandler
CGUPInterface
CIAssetAccessor	A callback interface for declaring and modifying an asset reference
►CICustomControl
CIColorSwatch
CICUIFrame
CICustButton
CICustEdit
CICustImage
CICustImage2D
CICustSeparator
CICustStatus
CICustStatusEdit
CICustToolbar
CIDADWindow
CIRollupWindow
CISliderControl
CISpinnerControl
CIVertToolbar
►CIDataChannel
CIFaceDataChannel
CIInteractiveRender
CIIRenderMgr
CIIRenderMgrSelector
CILoad
►CIMenuContext	Represents the interface to the various menu types such as MenuBar, QuadMenus, and right-click Popup Menus
CIMenuBarContext	This abstract class represents an interface for a menu bar context
CIQuadMenuContext	This abstract class represents the interface for a quad menu bar context
CIMergeManager
CIMtlParams
CINodeDisplayControl
CIParamMap2
CIRayTexmap
CIRendParams	This is the interface given to a renderer, or atmospheric effect when it needs to display its parameters
CIReshadeFragment
►CIRollupCallback	Class IRollupCallback : public InterfaceServer
CRolloutFloater
CIRollupPanel	Class IRollupPanel : public InterfaceServer
CIRollupRCMenuItem	Class IRollupRCMenuItem : public InterfaceServer
CISave
►CISubObjType	Developers have to return a class derived from this class with implementations for all the methods when implementing sub-objects for objects and modifiers (see BaseObject::GetSubObjType())
CGenSubObjType	This class provides a generic implementation for sub-object types
CITVUtility
►CLocalModData	This class allows a modifier to store application specific data
CLagModData
CMacroDir
►CMaxIcon
CMaxBmpFileIcon
CMeshDeltaUser
►CNodeDisplayCallback
CNodeDisplayCallbackEx
CObjectConverter	This virtual class is implemented by applications that want to supply a conversion method from one object type to another
►CParamDlg
CIAutoMParamDlg
CShaderParamDlg	A shader parameter dialog class
CPBAccessor
CPBValidator
►CPickModeCallback
CPickerControlMode
CPOPickPatchAttach
CSSPickSplineAttach
►CPostLoadCallback
CParamBlock2PLCB
CParamBlockPLCB	This is a handy post load call back for fixing up parameter blocks
CValueLoadPLCB
►CRenderData
►CLightDesc
CObjLightDesc	A light must be able to create one of these objects to give to the renderer
►CRestoreObj
CAppendGizmoRestore
CDeletedRestore
CDeleteGizmoRestore
CJPLimitsRestore
CPatchObjectRestore
CRealWorldScaleRecord< T >	Class for creating undo record for any class with a "Real-World Map Size" property
CRefMgrAddDeleteRestore< T >	Restore class for RefTarget class Note, Do not use this class as this is used by the internal system only
CSamplingCallback
►CSelectFilterCallback
CMSSelectFilterCallback
CSetKeyModeCallback
CSetKeyModeInterface
►CSFXParamDlg
CIAutoEParamDlg
CShadeContext
CTrackViewFilter
CTrackViewUtility
CView	This class is passed in to GeomObject::GetRenderMesh() to allow objects to do view dependent rendering
►CViewExp
►CViewExp10	Extends ViewExp
►CViewExp11	Extends ViewExp10
►CViewExp13	Extends ViewExp11
CViewExp18	Extends ViewExp13
CViewportDisplayCallback	Enables non-geometric plugins to draw in the viewport
►CViewWindow
CListenerViewWindow
►CXTCObject
CTriObjectNormalXTC
CIntersectionCallback2D
CIntersectionCallback3D
CInterval
CIOffScreenBuf
CIOurBipExport
CIPainterCanvasInterface_V5
CIPainterCanvasInterface_V5_1
CIPainterCanvasInterface_V7	This is the additional functionality in the Max7.0 version of the PainterCanvas
►CIPainterInterface_V5
►CIPainterInterface_V7
CIPainterInterface_V14
CIPainterRightClickHandler
►CIParamArray
CDynamHelperObject
CIParamBlock
CIParameterManager	A data management class for accessing data required for displaying real time effects
CIParamMap
►CIPatchOps
CPatchObject
►CIPatchSelect
CPatchObject
►CIPatchSelectData
CPatchObject
CIPhyContextExport
CIPhyContextImport
CIPhysiqueExport
CIPhysiqueImport
►CIPhyVertexExport
CIPhyBlendedRigidVertex
CIPhyDeformableOffsetVertex
CIPhyFloatingVertex
CIPhyRigidVertex
►CIPhyVertexImport
CIPhyBlendedRigidVertexImport
CIPhyRigidVertexImport
CIPoint2
CIPoint3
CIProjectionIntersector
CIProjectionRenderHandler
CIProjectionRenderHandler::ProjectionResult
CIPropertyContainer	Property container
CIRefTargMonitor	The interface for an owner of a RefTargMonitorRefMaker class
CIRenderMesh	Maintains a Dx version of the current mesh in the cache. It will render either the 3ds Max mesh or a screen aligned quad
CIRenderMeshCache	This class maintains a list of the meshes and RenderMeshes used per instance. It acts as a factory class
CIRenderMessageManager	An interface to manage the renderer messages (error, warning, progress, etc.)
CIRenderPresetsManager
CIRenderSSEControl
►CIReshading
CShader	Used by developers to create Shader plug-ins
CIRollupWindowDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping IRollupWindow pointers
►CIRTShaderManager	A simple public manager for IRTShaderNode
CIRTShaderManager2	An extension to the IRTShaderManager interface
CIRTShaderNode	A Hardware shader node for use with compiled shader trees
CIScene
CISect
CISectList
CISetKey
CIShadowLightData	Access shadow data from 3ds Max lights
CISkin
CISkin2	class ISkin2
CISkinContextData
CISkinImportData	class ISkinImportData
CISliderControlDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ISliderControl pointers
CISoftSelect
CISpinnerControlDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping ISpinnerControl pointers
►CISplineOps
CSplineShape
►CISplineSelect
CSplineShape
►CISplineSelectData
CSplineShape
CIStdDualVSCallback
►CISubMap
CMSCustAttrib
CMtlBase
►CISubMtlAPI
CPatchObject
CSplineShape
CISubTargetCtrl	ISubTargetCtrl gives access to sub-transform controller
CISystemXRef	Interface for interactions between 'systems', in particular biped, and the max xref core
CITabbedDialog
CITabPageProc
CITargetedIO
CItemID	An ID for a Menu or Menu Item
CITextObject
CITreeEnumProc
CIUnReplaceableControl	Basically it's a backwards-compatabile fix for the fact that the 'IsReplaceable' control flag isn't used by PB2's. Secondly the class provides
CIUtil
CIValidateNodeCallback	A simple class that a developer must implement if they want to use Scene traversal
CIVertexPaint::FaceColor
►CIVertexShader
CIDX9VertexShader
CIStdDualVS
CIVertToolbarDestructorPolicy	Class representing the DestructorPolicy for AutoPtr instances wrapping IVertToolbar pointers
►CIViewportButton	Viewport button abstraction
CViewportTextButton	A simple text based button implementation of the IViewportButton
CIWavePaint
CIWaveSound	SeeAlso: Class Interface
CJob
CJOBFRAMES
CJobList
CJobRenderElement
CJobServer
CJobText
CJointDlgData
CKeyReduceStatus
CLayerParentChange	This is a struct for NOTIFY_LAYER_PARENT_CHANGED BroadcastNotification layerChanged is the pointer on the layer that has changed parent
CLightRayTraversal	This is a callback class that can be given to a ObjLightDesc to have a ray traced through the light volume
CLightState	This structure describes the properties of a light
CLineBuffer	A line buffer, containing a single Point3 and color
CLinkedEntryT< T >
►CLinkedListT< T, TE >
CBMM_IOList	This class is used for storing a linked list of Bitmap Manager BMM_IOHandler objects
CLinkedListT< MSTR, MSTREntry >
CLoadSaveRetargetData	Class used to input retargeting info when creating a map file
CLoadSubAnimInfo	Structure specifying which controllers to load from a BIP file
CLogLUV24Pixel
CLogLUV32Pixel
CLogSys	Class for writing out log information to a file
CMacroButtonData
CMacroRecorder::MacroRecorderDisable	Class for easily & safely disabling the macro recorder
CMainThreadTask	Derive from this class to pass a task to be executed on 3DS Max main thread
CManagerInfo
CMapBitArray	This class can be used to store a bit per map channel, including both negative and positive map channels, and it works with any size index
CMapDelta	Represents some kind of change to a mesh map
CMapSampler
►CMarketDefaults	This class manages the default settings of a range of 3ds Max features
CMarketDefaults13
CMarketDefaults::Range< T, low, high >
CMatrix2
►CMatrix3
CIdentityTM	This class is another version of Matrix3 where the matrix is initialized to the identity by the default constructor
►CMatrix3Indirect
►CDelayedMatrix3
CDelayedNodeMat
CMatrix3Stack
CMAXException
CMAXFileOpenDialog
CMAXFileSaveDialog
CMaxJob
CMaxJobRenderElements
CMaxLocaleHandler	MaxLocaleHandler handles Globalization
CMaxMixerManager	A class that allows a user to access the new max mixers in max 8
►CMaxNet
CMaxNetManager
CMaxNetCallBack
►CMaxNetFile
►CMaxNetEngine
CMaxNetJob	Network Job
CMsgFromMax
CMsgFromSrv
►CMaxNetworkInterface
CMaxNetworkInterface2
►CMAXScriptException
►CCompileError
CSyntaxError
CDebuggerRuntimeError
CFunctionReturn
CLoopContinue
CLoopExit
►CMAXScriptRuntimeErrorException
CAccessorError
CArgCountError
CAssignToConstError
CConversionError
CIncompatibleTypes
CNoMethodError
CRuntimeError
CTypeError
CUnknownSystemException
CUserThrownError
CSignalException
CMAXScriptException::ScopedMXSCallstackCaptureDisable	Helper class for disabling mxs callstack capture if an exception is thrown
CArray< T >	A generic array container, with proper support for non-POD types
CAssetId
CEdgeDescr
CIContext	Class IContext does all the actual skin weight computations
CIMesh	Class IMesh describes the mesh to be used to compute the skin weights
CIProgress	Class IProgress just a class that the solver uses to tell how far along the process is and allows the user to cancel out of the process
CISparseVertexWeights	Class ISparseVertexWeights describes the weights that are assigned to a skin
CITransformHierarchy	Class ITransformHierarchy describes the skeleton to be used to compute the skin weights
CAtomicRefCounter	This class contains an integer which is initialized to zero
CAutoRestoreRenderNodeMaterial	This is a utility class for assigning customized solid material to the solid mesh render item of a render node when generating render items from IMeshDisplay2::GetRenderItems() during the execution of BaseObject::UpdatePerNodeItems()
CAutoRestoreWorldMatrix
CBlendState	This class holds the blend state for all render targets
►CConnectionPoint	ConnectionPoint is the base class that manages the connections between view fragments
CInput	Class that stores input information for a fragment
COutput	Class that stores output information for a fragment
CConsolidationData	This a structure that holds parameters used for render item consolidation
CDefaultLifeTimePolicy< RefObjectType >
CDepthStencilState	This class encapsulates a complete depth buffer and stencil buffer state
CDeviceCaps	This struct is used to store some device related information
CDisplayCallbackContext	This class contains context which can be queried in IDisplayCallback
CDrawContext	Typically ICustomRenderItem::Draw() and ICustomRenderItem::HitTest() bring instance of this class as parameter
CFragmentMessageParameter	Message parameters
CGenerateMeshRenderItemsContext	This class contains all information that will be passed to Mesh::GenerateRenderItems() or MNMesh::GenerateRenderItems() to update its display data
CHitTestContext	This is a hit test context class
CHLSLMaterialHandle::ParameterDesc	This is parameter description of HLSLMaterialHandle parameter
►CIConsolidationStrategy	This class defines a strategy to consolidate one type of consolidation key
CMarkerConsolidationStrategy	This class defines a marker item consolidation strategy
CMeshEdgeConsolidationStrategy	This class defines an immediate mesh edge render item consolidation strategy
CSplineConsolidationStrategy	This class defines a spline item consolidation strategy
►CIDisposable
CIDisplayCallback	A developer would implement this interface to allow immediate mode drawing of primitives, text and markers
CIFixedViewportPipeline	This class provide some facility to add some extended behavior to the fixed render pipeline
CIPrimitiveRenderer	This class is used to draw simple primitives, markers, text with given material and transformations
►CIRefObject	This class is similar to IUnknown in COM
►CARefObject	This class implemented IRefObject interfaces
►CFragment	Fragment is the base computation unit in the view system
CFragmentGraph	FragmentGraph is a graph consisting of fragment nodes
CViewFragment	Base class of all viewport fragment
CICamera	The interface of a render camera for nitrous viewport
►CIConsolidationKey	This class is used as a key for a hash table
CMarkerItemKey	This is a utility class for provide a key for marker consolidation item
CMeshEdgeKey	This is a utility class for provide a key for MeshEdgeRenderItem
CSplineItemKey	This is a utility class for provide a key for spline consolidation item
CICustomRenderItem	This class is used to customize the behavior of a render item
CIDisplayCallback	A developer would implement this interface to allow immediate mode drawing of primitives, text and markers
CIRenderGeometry	IRenderGeometry is a presentation of geometry
►CIView	This class is a representation of a basic view
►CIRenderView	This class is a representation of a render view which provides some common functions to manipulate a viewport
CIRenderView2	IRenderView2 provide the access to IFixedViewportPipeline with which 3rd party developer can add some extended behavior to the fixed render pipeline
CViewParameter	This class wrap up all viewport related parameters
►CIRenderItemContainer	A render item container, it provides various methods to access the contained render items
CRenderItemHandleArray	This is a utility class
CIRenderStateManager	IRenderStateManager controls primitive renderer's current render style
CIVirtualDevice	This class provides low level access to the GPU device
CLockedRect	Defines a rectangular region that has been locked by a call to TextureHandle::LockRect()
CMaterialRequiredStreamElement	This struct describes a single stream element that will be used by the hardware shader of a material
CMaterialRequiredStreams	This class is used for describing the mesh stream requirements of a material
CMatrix44
CMeshElementDescription	This class describes a single mesh element(which corresponds to a render item) required to be generated by calling Mesh::GenerateRenderItems() or MNMesh::GenerateRenderItems() from the specified mesh(or mnmesh)
CRasterizerState	This class encapsulates a complete rasterizer state, like fill mode, cull mode, point size, etc
CRefPtr< RefObjectType, SafeRefObjectType, LifeTimePolicy >	This template class act similar as CComPtr
CRenderRegion	Note: The render region can set the clipping rectangle,offset and scale of render target in the screen space of render view
CSimpleVertexStream	Used by DrawPrimitive and DrawIndexedPrimitive for vertex data
►CSmartHandle	This is the base wrapper class for all graphics primitive classes in max viewport: worlds, nodes, render items, materials, etc
►CBaseMaterialHandle	This is base graphics material class
CHLSLMaterialHandle	HLSLMaterialHandle is a material class to support HLSL custom material
CSolidColorMaterialHandle	SolidColorMaterialHandle is a material class to support solid color
CStandardMaterialHandle	StandardMaterialHandle is a material class to support phong style material
CTextureMaterialHandle	This is material class to support material with texture
CVertexColorMaterialHandle	VertexColorMaterialHandle is a material class to support vertex color
►CBaseRasterHandle	This is our base graphics raster resource class
CMemoryTargetHandle	Application can use this class to create a render target in memory which can be a target input/output for a fragment node
►CTargetHandle	Application can use this class either as a render target or convert it to texture and assign to model
CPresentableTargetHandle	This class is similar as TargetHandle
CTextureHandle	This is texture class to support texture for material, such as TextureMaterialHandle
CCustomRenderStageHandle	CustomRenderStageHandle is the base wrapper class of the custom render stage
CEffectHandle	EffectHandle is a class provides features similar as Effect in Direct3D This class is used for viewport display and Quicksilver
CEffectInstanceHandle	EffectInstanceHandle is a class which stores values of parameters in an effect
CImmediateFragment	ImmediateFragment is a class which let application render primitives outside the render loop
CIndexBufferHandle	IndexBufferHandle is a memory buffer that contain index data
CQueryHandle	QueryHandle is a query object used for submitting hardware queries
►CRenderItemHandle	This is the base wrapper class for all viewport render items
CCustomRenderItemHandle	CustomRenderItemHandle is a wrapper of ICustomRenderItem
CGeometryRenderItemHandle	This is a special render item which used only by Mesh/MNMesh
CImmediateRenderItemHandle	This class is used to wrap user defined IDisplayCallback class
CRenderItemHandleDecorator	This is a decorator class for RenderItemHandle
CRenderNodeHandle	This class describes a graphics node
CRenderWorldHandle	RenderWorldHandle is the base wrapper class of the nitrous world
CVertexBufferHandle	VertexBufferHandle is a memory buffer that contain vertex data
CStencilOperation	This class encapsulates a complete set of stencil buffer operations for stencil test
CTargetBlendState	This class holds the blend state for single render target
CTextureCoordStream	This structure is used to define vertex's texture coordinate information
CTextureHandleUtility	This is utility class to create TextureHandle from Texmap
CUpdateDisplayContext	This class contains all information that will be passed to IObjectDisplay::UpdateDisplay and will be used by plugin to update its display data
CUpdateNodeContext	This class contains node dependent information for calling IObjectDisplay2::UpdatePerNodeItems(), and IObjectDisplay2::UpdatePerViewItems()
CUpdateViewContext	This class contains view dependent information for calling IObjectDisplay2::UpdatePerViewItems()
CMarkerConsolidationItem::ConsolidationData	Data structure used by the item
CMeshEdgeConsolidationItemDX11::ConsolidationData
CSplineConsolidationItem::ConsolidationData	Data structure used by the item
CVariable	Variable is a simple class that stores certain data that a developer can decide at runtime
CHoldBegin
CIPhysicalCamera::RenderTransformEvaluationGuard	A guard class which enables a physical camera INode to evaluate itself for ray-traced rendering (as opposed to viewport rendering)
CIPhysicalSunSky	Access to functionality and properties of the Physical Sun & Sky environment map
CIPhysicalSunSky::IShader	An object which encapsulates the evaluation (shading) of the Physical Sun & Sky environment
CIPhysicalSunSky::ShadingParameters	Encapsulates the set of shading parameters for the Physical Sun & Sky
►CSlateModelWrapper	SlateModelWrapper is a simple wrapper class that holds an internal pointer to a particle flow slate model
CPFSimpleAction
CThreadTools	This class lets control the amount of threading in different parts of Max */
CTimer	Just a helper class to record how long a task takes. Just call this at the start and EndTimer at the end will return the amount of time that has passed in milliseconds
CDoublePoint3
CIPointCloudVisibleVoxelNode	The interface for interacting with point cloud voxel nodes
CPointCloudVertex	A structure that contains the basic information about a point cloud vertex
CUBytePoint4
CIRenderingLogger	The Rendering API's interface for logging messages against 3ds Max build-in mechanisms
►CIRenderSession	Common base class for IOfflineRenderSession and IInteractiveRenderSession
CIInteractiveRenderSession	An interface which encapsulates a render session for interactive rendering
CIOfflineRenderSession	An interface which encapsulates a render session for offline (non-interactive) rendering
CITranslationManager	Manages the translation graph for a scene
CIMeshFlattener	Utility interface for creating a flattened representation of a mesh
CINodeInstancingPool::IManager	Manages the creation and existence of node instancing pools
►CTranslatorKey	Unique identifier for a translator in the scene's translation graph
CGenericTranslatorKey_Empty< TranslatorType, TranslatorAllocator >
CGenericTranslatorKey_SinglePointer< TranslatorType, PointerType, TranslatorAllocator >
CGenericTranslatorKey_SingleReference< TranslatorType, ReferencedType, TranslatorAllocator >
CGenericTranslatorKey_Struct< TranslatorType, StructType, Hash, TranslatorAllocator >
CCSkinEngine
►CBinaryStream	Represent an abstract binary stream of data
CBinaryStreamMemory	Holds binary data in memory only
CChar	Represents a single Unicode character
CCharAccumulator	Character accumulator
CCharIterator< ChType >	Iterate intelligently inside a string
►CException	Base exception class for 3ds Max
CNullDereferenceException	Thrown when a null pointer is dereferenced
►COutOfRangeException	Thrown when an out of bounds index is detected
CTabOutOfRangeException	Thrown when an invalid index is passed into Tab::operator[] or Tab::Addr
CRunTimeException	General multi-purpose exception for runtime errors
CIBailOutBusyProcessManager	An interface of bailing out the busy processing functions by pressing the 'Esc' key
CITipSystem	An interface of giving users a tip
CMaxString	Stores all the strings inside CStr and WStr
CMaxStringCast< ChType >	A MaxStringCast is used when casting a MaxString to a type
►CNoncopyable	Noncopyable is a handy utility mix-in base class that makes any class derived from it non-copyable
CActionTable	A table of action items that can be used by plug-ins to export tables of action items that can be used by the UI to attach to keyboard shortcuts, assigned to toolbar buttons, and add to menus
CAnimatable
CClassDirectory	This class represents the directory of all plug-in classes known to the system
CDataClassDesc	A proxy for a class descriptor
CDependentIterator	Iterates through all direct dependents of a given ReferenceTarget
CDllDir	Represents the plug-in DLL "directory", which is a registry of every plug-in DLL loaded by 3ds Max
CIActionManager10	A mixin-interface extension to IActionManager which allows a client to dispatch a Message back to the application if it is not handled by the focused control
CIBatchRenderView	This class represent one entry in the list of batch render views
CIFileResolutionManager
CIPublishedCustAttrib	Any CustAttrib which wants to support being published should implement this interface
CMacroEntry::DisableCompileGuard	Helper class for disabling macroscript compiles in an exception-safe manner
CIAssetManager
CIVariableDictionary	IVariableDictionary is a map structure that contains key/variable pairs
CMarkerConsolidationItem	This class collects all marker items(both immediate and non-immediate), hardware build vertex buffer and index buffer in Realize() function and render them in Display() function
CMarkerRenderItem	Base class for marker render items
CMeshEdgeConsolidationItemDX11	This class collects mesh edge render items and build hardware buffers for them
CMeshEdgeRenderItem	This class is designed for small meshes that only renders edge element
CSplineConsolidationItem	This class collects all spline items(both immediate and non-immediate), hardware build vertex buffer and index buffer in Realize() function and render them in Display() function
CSplineRenderItem	Base class for spline render items
CIPopulateIdleArea	IPopulateIdleArea is the interface class to Populate idle area objects
CIRenderingProcess::NamedTimerGuard	Guard class for starting and stopping a timer automatically
CITranslatorOutput	Base class for all translator outputs
►CTranslator	Base class for a translator
CBaseTranslator_Camera	Base class for translating the scene camera
CBaseTranslator_INode	Base class for translating an INode
CBaseTranslator_Object	Base class for translating the object referenced by a node instancing pool
CBaseTranslator_ReferenceTarget	Base class for translating an arbitrary ReferenceTarget
CUnifiedRenderer	Unifies functionality for, both, interactive (ActiveShade) and offline (Production) rendering
CIDlgShowingStatusForPolyObj	A pure virtual interface for Poly Object's UI as dialog Showing Status
CScopedTrace	A diagnostic class used for tracing
CVariableGuard< T >	Resets a variable when the object goes out of scope
CWindowsMessageFilter	Runs a message loop without blocking, allowing only acceptable Windows messages through to their destination UI controls
CMXS_Exit_ValueLocal_Scope	Class that uses the RAII idiom to push/pop the thread local current_locals_frame
CMXSToolTipExtender
CReferenceSaveManager	Used to specify and enumerate the save reference hierarchy, if different from the normal reference hierarchy
CScopedErrorTracebackDisable	Class that uses the RAII idiom to push/pop the error traceback disable state
CScopedMaxScriptEvaluationContext	Class that uses the RAII idiom to create a maxscript visible stack frame
CScopedMaxScriptSEHandler	Class that uses the RAII idiom to push/pop setting a structured error handler
CScopedPushCallContext	Class that uses the RAII idiom to push/pop a CallContext
CScopedPushControl	Class that uses the RAII idiom to push/pop the thread local current_controller
CScopedPushPlugin	Class that uses the RAII idiom to push/pop the plugin stored in thread local current_plugin
CScopedPushStruct	Class that uses the RAII idiom to push/pop the struct stored in thread local current_struct
CScopedSaveCurrentFrames	Class that uses the RAII idiom to save and restore the current frame data
CScopedValueTempArray	Class that uses the RAII idiom to allocate and deallocate value temp arrays
CSubClassList	A collection of ClassEntry objects that have the same super class id
CPath	Path type - adds path-operation richness over symbol strings
CStopWatch	A basic timer tool
►CBaseTextReader	This class is the base for all text file readers
CReader	Reads and interprets text files
CReaderWriter	This class is used to access text file with both reader and writer functionality
►CBaseTextWriter	This class is the base for all text file writers
CReaderWriter	This class is used to access text file with both reader and writer functionality
CWriter	Write Text files
CVertexNormal	The class used to compute vertex normals considering smoothing
►CMaxStringCast< char >
CMaxStringCastCP	A Utility class for helping to convert to a specified code page
CMaxStringCastUTF8	A Utility class for helping to convert to UTF8
CMCInputDevice
CMEdge
CMenuColors
CMenuEvent	Represents a Menu Event
CMergeable	Description: This class allows referenceTargets that are not INodes to be mergeable through the File->Merge command
CMeshAccess
CMeshCapInfo
CMeshCapper	This class is used to apply the MeshCapInfo data to a mesh
CMeshCapPoly
CMeshCapVert
CMeshChamferData
CMeshData
CMeshDeltaUserData
CMeshFaceData
CMeshMap	In 3ds Max 3.0 and later the user may work with more than 2 mapping channels
CMeshNamedSelClip
CMeshNormalFace	See Also: class MeshNormalSpec This class is used to store specified normal information for a particular face in a Mesh
CMeshOpProgress	A callback used while doing a lengthy operation to a mesh
CMeshRenderData	A developer may derive a class from this class, put any required data in it, and then hang this data off a Mesh
CMetaParticle
CMixerManager
CMNChamferData	Contains all the data needed to move points (and map vertices) as the user drags a chamfer or extrude
CMNChamferData10	MNChamferData for use with IMNMeshUtilities10::ChamferEdges
CMNEdgeClusters	Represents a list of edge "clusters" for a given MNMesh
CMNFaceClusters	Used for grouping faces in an MNMesh into clusters for applying transformations
CMNFaceElement	Used to assist in the process of sorting MNMesh faces into separate elements
CMNMapFace	Used to store map vertex information for a given face and map channel
CMNMapPreserveData	This class is used to "preserve" mapping coordinates while moving vertices
CMNMeshBorder	Hold boundary information for an MNMesh mesh
CMNMeshUtilities	Provides a number of utility functions for working with MNMesh
CMNNormalFace	This stores specified normal information for a given face
CMocapManager
CModContextEnumProc	Callback object used with Modifier::EnumModContexts()
Cmsgdata
CMultFprintParams
CMultiSelectCallback	This is the callback object used to perform the [de]selection via Animatable:: SvGetMultiSelectCallback()
CNameAccum
CNameChange	The name change call parameter structure
CNamedPolySelSetList
CNamedSegSelSetList
CNamedVertSelSetList
CNameMaker	Creates unique names
CNetworkStatus
CNodeIterator
CNoteKey
CNotifyCustomAttribute	Structure used with NOTIFY_CUSTOM_ATTRIBUTES_ADDED and NOTIFY_CUSTOM_ATTRIBUTES_REMOVED notifications
CNotifyInfo	3ds Max supports a system where a plug-in can ask to receive a callback when certain events occur
CNotifyPreEval_FrameInfo	The call parameter that accompanies the notification code NOTIFY_RENDER_PREEVAL_FRAMEINFO is a pointer to this struct, which contains information about the view and the frame to be rendered
CNURBSDisplay
CNURBSFuseCurveCV
CNURBSFuseSurfaceCV
►CNURBSObject
CNURBSControlVertex
►CNURBSCurve
CNURBSBlendCurve
CNURBSChamferCurve
►CNURBSCVCurve
CNURBSCurveOnSurface
CNURBSFilletCurve
CNURBSIsoCurve
CNURBSMirrorCurve
CNURBSOffsetCurve
►CNURBSPointCurve
CNURBSPointCurveOnSurface
CNURBSProjectNormalCurve
CNURBSProjectVectorCurve
CNURBSSurfaceEdgeCurve
CNURBSSurfaceNormalCurve
CNURBSSurfSurfIntersectionCurve
CNURBSXFormCurve
►CNURBSPoint
CNURBSCurveConstPoint
CNURBSCurveCurveIntersectionPoint
CNURBSCurveSurfaceIntersectionPoint
CNURBSIndependentPoint
CNURBSPointConstPoint
CNURBSSurfConstPoint
►CNURBSSurface
CNURBS1RailSweepSurface
CNURBS2RailSweepSurface
CNURBSBlendSurface
CNURBSCapSurface
CNURBSCVSurface
CNURBSExtrudeSurface
CNURBSFilletSurface
CNURBSLatheSurface
CNURBSMirrorSurface
CNURBSMultiCurveTrimSurface
CNURBSNBlendSurface
CNURBSOffsetSurface
CNURBSPointSurface
CNURBSRuledSurface
CNURBSULoftSurface
CNURBSUVLoftSurface
CNURBSXFormSurface
CNURBSTexturePoint
CNURBSProceeduralCurve
CNURBSProceeduralSurface
CNURBSSet
CNURBSTextureChannel
CNURBSTextureChannelSet
CNURBSTextureSurface
CNURBSTrimPoint
CObjectDataReaderCallback
CObjectDefinitionChangeNotificationParam	The object redefinition call parameter structure
CObjectState	The ObjectState is the structure that flows up the geometry pipeline
CObjectWrapper
COpenBezFont	A class used to list the fonts currently open
►COrbazTrueBlock
COrbazTrueBlockIterator
►COsnap
COSnapDecorator
COsnapMarker
CParamAlias
CParamBlockDesc2::map_spec
CParamDef
►CParamDimensionBase
CParamDimension
CParamMap2UserDlgProc
►CParamMapUserDlgProc
CSimpleSplineDlgProc
CParamUIDesc
CParamVersionDesc
CParticleChannelMask
CParticleID
CParticleSys
CPatchCapInfo	This is the information class for patch capping
CPatchCapper
CPatchCapPoly
CPatchCapVec	Patch cap vectors
CPatchCapVert	Patch cap vertices
CPatchEdge
CPatchNamedSelClip
CPatchSubHitRec
CPatchTVert
CPatchVec
CPatchVert
Cpath_properties
Cpath_property
CPB2Value
CPBBitmap
CPerData	This class is used for per -'something' floating-point information
CPerformOut	This structure is sent to the BaseBehavior Perform function
CCreatedChannelLinker
CPFActiveActionDataRequest
CPickAnimatableCallback
CPickClassCallback
►CPickNodeCallback
CPickerControlFilter
CPOPickPatchAttach
CSSPickSplineAttach
CPickObjectProc
CPixelBufT< T >
CPoint2
CPoint3
CPoint4
CPolyLine	Describes a single polygon in a PolyShape using linear segments
►CPolyLineProc	This is a callback used to draw a series of lines
CBoxLineProc	This class provides a bounding box and a matrix
CDrawLineProc	This class provides a simplified way to draw a connected series of lines to the GraphicsWindow passed to the class constructor
CPolyPt	Represents a single point of a PolyLine
CPolyShape	A multi-polygon shape class
CPOModRecord
►CPostPatchProc
CRefTargMonitorRefMaker	Defines a class for monitoring a ReferenceTarget
CPreciseTimeValue
CPreviewParams
CPrintManager
CPropertyEnum	Property Enumeration
CPRVertex
►CPtrVector	Class PtrVector
CPtrVec< T >
CQuantizer
CQuat
CRandGenerator	Class RandGenerator
CRandObjLinker
CRandom
CRay
CRCMData
CRealPixel
CRedrawViewsCallback
CRefEnumProc	A callback class for ReferenceMaker::EnumRefHierarchy
CRefPtr< IGPUDisplayRenderItem >
CRefPtr< ViewParameter >
CRefTarget	Note, Do not use this class as this is used by the internal system only
►CRemapDir	For remapping references during a Clone
CDefaultRemapDir	Implements a default version of a RemapDir
CRendContext	This class is passed into the method ObjLightDesc::Update()
CRenderInfo
CRenderInstance	This class provides information about a single node being rendered
CRenderMapsContext	An instance of this class is passed into the MtlBase::BuildMaps() method
CRenderPresetsContext
►CRendParamDlg	An instance of this class is created by Renderer::CreateParamDlg()
CIAutoRendererParamDlg	Implementation of a ParamDlg that handles the automatic creation and lifetime management for a parameter map of a renderer plugin
CRendParams	This class has a set of data members, and these parameters are passed to the renderer when the renderer is opened
CRendPickProc	An instance of this class is passed to IRendParams::SetPickMode()
►CRendProgressCallback	This class is a callback passed in to the renderer
CIInteractiveRender::IProgressCallback	This class represent a callback object which can be used with an interactive renderer. Information set via RendProgressCallback::SetCurField() or RendProgressCallback::SetSceneStats() will be ignored. If a title is set via the inherited method SetTitle(), it will appear in the main status bar, but will be replaced by the 'IRenderTitle' when necessary. An interactive renderer should abort if RendProgressCallback::Progress() returns RENDPROG_ABORT
CResourceMakerCallback
►CRightClickMenu
CMSRightClickMenu
CRightClickMenuManager
CRNormal
CRotationValue
CRVertex
►CSaveEnumProc	A callback class for saving dependents
CReferenceSaveManager::PostSave	Used to tear down a save reference hierarchy
CReferenceSaveManager::PreSave	Used to prepare a save reference hierarchy
CSaveSubAnimInfo	Structure specifying which controllers to save in a BIP file
CScaleValue
CSceneExport
CSceneImport
CSceneInfo
CSchedule	Used by the Network Rendering API to store hourly scheduling information
CSClassUIInfo	This class allows developers to provide some additional information on a superclass
CScopedPrePostRefNotifyDependents
CScript
CScriptItem
CServerInfo
CServerList
CSetMorphTargetPacket
CSetXFormPacket
CShadBufRenderer
►CShadowGenerator
CAreaShadowGenerator
CShadowParamDlg
CShapeContextCallback
CShapeHierarchy
CShapeNamedPolySelClip
CShapeNamedSegSelClip
CShapeNamedVertSelClip
CShapePSel
CShapeSSel
CShapeSubHitRec
CShapeVSel
CSimpleRandom
CSlot
CSnapInfo	Describes the snap settings used for snap operations
CSnippet
CSpaceArrayCallback
CSphereData
CSpline3D	General-purpose 3D spline class
CSplineKnot	Describes a single knot in a spline
CSplineKnotAssy	Used for the internal storage of spline knot assemblies in the Spline3D class
CSplinePoint	Provides the vertex-level point information for the Spline3D class
CSplineShapePointTab
CSplineShapeVertexDelta
CSpringClass
CSpringSysClient
CSSConstraintPoint
CSSNamedSelSetList
CSSParticle
CSSParticleCache
CStack< T >	A simple stack implementation
CStack< HMENU >
CStack< IMenu * >
CStatistics
CStrip	Graphics Strip Class
CStripData
CSubObjAxisCallback
CSubObjHitList	This class describes a list of sub-object hit records
CSubPatchHitList
CSubShapeHitList	Class SubShapeHitList
CSurfTabEntry
CSuspendAll	Suspends various system states in an exception safe manner
CSvGraphNodeReference	A small container type class that associates graph nodes with traversal status
CTab< T >	Generic container class
CTab< AColor * >
CTab< ActionItem * >
CTab< AdjFace >
CTab< AngAxis * >
►CTab< AnimProperty * >
CAnimPropertyList
CTab< AppDataChunk * >
CTab< AvailableFont * >
CTab< BaseInterface * >
CTab< BezFontDll * >
CTab< BezierShape * >
CTab< BitArray * >
CTab< BOOL >
CTab< bool >
CTab< Box3 * >
CTab< BYTE >
CTab< CacheClass >
CTab< Candidate * >
CTab< char >
CTab< CharStream * >
CTab< Class_ID >
CTab< ClassDesc * >
CTab< ClassEntry * >
CTab< CollisionObject * >
CTab< Color * >
►CTab< const MCHAR * >
CNameTab	This class is used to store a table of names
CURLTab
CTab< const MCHAR >
CTab< Control * >
CTab< double >
CTab< DropClipFormat * >
►CTab< DWORD >
CDWORDTab
CTab< EdgeBondage >
CTab< FaceChange >
CTab< FaceCreate >
CTab< FaceRemap >
CTab< FaceSmooth >
CTab< FileDropType * >
CTab< float >
CTab< ForceField * >
CTab< FPEnum * >
CTab< FPEnum::enum_code >
CTab< FPFunctionDef * >
CTab< FPInterface * >
CTab< FPInterfaceDesc * >
CTab< FPParamDef * >
CTab< FPPropDef * >
CTab< FPValue * >
CTab< GFX_MESH::GFX_MESH::HWTupleMesh * >
CTab< GFX_MESH::HWIndexBuffer * >
CTab< HMENU >
CTab< HookPoint >
CTab< HWND >
CTab< IGameModifier * >
CTab< IMenu * >
►CTab< INode * >
CINodeTab	Class representing a dynamic array of INodes
CTab< Inst >
►CTab< int >
CNumList
CTab< INT64 >
CTab< INT_PTR >
CTab< Interface_ID >
CTab< InterfaceNotifyCallback * >
CTab< InterpolationData * >
CTab< Interval * >
CTab< IObject * >
CTab< IParamMap2 * >
CTab< IPoint2 >
CTab< ManipulatorGizmo * >
CTab< MapID >
CTab< MapInterpolationData * >
CTab< Matrix3 * >
CTab< Matrix3 >
CTab< MEdge >
CTab< Mesh * >
►CTab< ModContext * >
CModContextList	A modifier may be applied to several objects in the scene
CTab< Mtl * >
►CTab< MtlBaseHandle >
►CMtlBaseList	Simple list of MtlBase
CMtlBaseLib
►CTab< MtlHandle >
►CMtlList
CMtlLib
►CTab< MZPExtraction * >
CTabMZPExtraction
►CTab< NoteKey * >
CNoteKeyTab
CTab< NURBSFuseCurveCV >
CTab< NURBSFuseSurfaceCV >
CTab< NURBSId >
CTab< NURBSObject * >
CTab< NURBSTextureChannel * >
CTab< Object * >
CTab< OpenBezFont * >
CTab< ParamBlockDesc2 * >
CTab< ParamBlockDesc2::map_spec >
CTab< PatchTVert * >
CTab< PBBitmap * >
CTab< PEventUser >
CTab< POINT * >
CTab< Point2 * >
CTab< Point3 * >
CTab< Point3 >
CTab< Point4 * >
CTab< PRightClickMenu >
CTab< Quat * >
CTab< RandGenerator * >
CTab< Ray * >
CTab< RCMData >
CTab< ReferenceTarget * >
CTab< ReferenceTarget >
CTab< Rollout * >
CTab< rollout_control >
CTab< RolloutControl * >
CTab< ShapePSel * >
CTab< ShapeSSel * >
CTab< ShapeVSel * >
CTab< size_t >
CTab< SpringClass >
CTab< T * >
CTab< Tab< float > * >
CTab< Tab< int > * >
CTab< Texmap * >
CTab< TimeValue >
►CTab< tooltabentry * >
CToolTab
CTab< TriFaceData * >
CTab< TriStrip * >
CTab< TVFace >
CTab< TVPatch * >
CTab< ULONG >
CTab< unsigned int >
CTab< UVVertSet >
CTab< Value * >
CTab< VertexNormalsCallback * >
CTab< VertMove >
CTab< void * >
CTab< WORD >
CTab< WStr * >
►CTab< XMLAnimTreeEntry * >
CXMLAnimTreeEntryList	The list of XMLAnimTreeEntry tracks, that will then be loaded onto, or saved out, or put into the mixer
CTab< XTCContainer * >
CTabDialogPointer
CTABDLG_NMHDR
CTabHd< T >
CTabHd< AColor * >
CTabHd< ActionItem * >
CTabHd< AdjFace >
CTabHd< AngAxis * >
CTabHd< AnimProperty * >
CTabHd< AppDataChunk * >
CTabHd< AvailableFont * >
CTabHd< BaseInterface * >
CTabHd< BezFontDll * >
CTabHd< BezierShape * >
CTabHd< BitArray * >
CTabHd< BOOL >
CTabHd< bool >
CTabHd< Box3 * >
CTabHd< BYTE >
CTabHd< CacheClass >
CTabHd< Candidate * >
CTabHd< char >
CTabHd< CharStream * >
CTabHd< Class_ID >
CTabHd< ClassDesc * >
CTabHd< ClassEntry * >
CTabHd< CollisionObject * >
CTabHd< Color * >
CTabHd< const MCHAR * >
CTabHd< const MCHAR >
CTabHd< Control * >
CTabHd< double >
CTabHd< DropClipFormat * >
CTabHd< DWORD >
CTabHd< EdgeBondage >
CTabHd< FaceChange >
CTabHd< FaceCreate >
CTabHd< FaceRemap >
CTabHd< FaceSmooth >
CTabHd< FileDropType * >
CTabHd< float >
CTabHd< ForceField * >
CTabHd< FPEnum * >
CTabHd< FPEnum::enum_code >
CTabHd< FPFunctionDef * >
CTabHd< FPInterface * >
CTabHd< FPInterfaceDesc * >
CTabHd< FPParamDef * >
CTabHd< FPPropDef * >
CTabHd< FPValue * >
CTabHd< GFX_MESH::GFX_MESH::HWTupleMesh * >
CTabHd< GFX_MESH::HWIndexBuffer * >
CTabHd< HMENU >
CTabHd< HookPoint >
CTabHd< HWND >
CTabHd< IGameModifier * >
CTabHd< IMenu * >
CTabHd< INode * >
CTabHd< Inst >
CTabHd< int >
CTabHd< INT64 >
CTabHd< INT_PTR >
CTabHd< Interface_ID >
CTabHd< InterfaceNotifyCallback * >
CTabHd< InterpolationData * >
CTabHd< Interval * >
CTabHd< IObject * >
CTabHd< IParamMap2 * >
CTabHd< IPoint2 >
CTabHd< ManipulatorGizmo * >
CTabHd< MapID >
CTabHd< MapInterpolationData * >
CTabHd< Matrix3 * >
CTabHd< Matrix3 >
CTabHd< MEdge >
CTabHd< Mesh * >
CTabHd< ModContext * >
CTabHd< Mtl * >
CTabHd< MtlBaseHandle >
CTabHd< MtlHandle >
CTabHd< MZPExtraction * >
CTabHd< NoteKey * >
CTabHd< NURBSFuseCurveCV >
CTabHd< NURBSFuseSurfaceCV >
CTabHd< NURBSId >
CTabHd< NURBSObject * >
CTabHd< NURBSTextureChannel * >
CTabHd< Object * >
CTabHd< OpenBezFont * >
CTabHd< ParamBlockDesc2 * >
CTabHd< ParamBlockDesc2::map_spec >
CTabHd< PatchTVert * >
CTabHd< PBBitmap * >
CTabHd< PEventUser >
CTabHd< POINT * >
CTabHd< Point2 * >
CTabHd< Point3 * >
CTabHd< Point3 >
CTabHd< Point4 * >
CTabHd< PRightClickMenu >
CTabHd< Quat * >
CTabHd< RandGenerator * >
CTabHd< Ray * >
CTabHd< RCMData >
CTabHd< ReferenceTarget * >
CTabHd< ReferenceTarget >
CTabHd< Rollout * >
CTabHd< rollout_control >
CTabHd< RolloutControl * >
CTabHd< ShapePSel * >
CTabHd< ShapeSSel * >
CTabHd< ShapeVSel * >
CTabHd< size_t >
CTabHd< SpringClass >
CTabHd< T * >
CTabHd< Tab< float > * >
CTabHd< Tab< int > * >
CTabHd< Texmap * >
CTabHd< TimeValue >
CTabHd< tooltabentry * >
CTabHd< TriFaceData * >
CTabHd< TriStrip * >
CTabHd< TVFace >
CTabHd< TVPatch * >
CTabHd< ULONG >
CTabHd< unsigned int >
CTabHd< UVVertSet >
CTabHd< Value * >
CTabHd< VertexNormalsCallback * >
CTabHd< VertMove >
CTabHd< void * >
CTabHd< WORD >
CTabHd< WStr * >
CTabHd< XMLAnimTreeEntry * >
CTabHd< XTCContainer * >
CTabHdr
CTangentBasis
CTCBGraphParams
CTemplate
CTemplate3D
CTempStore
CTessApprox
CTexHandle
►CTexHandleMaker
►CDisplayTextureHelper	Used for creating texture handles (TexHandle) and updating texture data managed by the viewport display system
CDisplayTextureHelperExt	DisplayTextureHelperExt extends DisplayTextureHelper to support more textures Used for creating stage texture handles (TexHandle) and updating texture data managed by the viewport display system
CMtlMakerCallback
CTextBufferOutput
►CTimeChangeCallback
CRolloutChangeCallback
CTimeChange
CTimeMap
CTMComponentsArg
CToneOperator::ThreadedProcessor	Enables processing a tone operator independently of class ToneOperator, for example in a multi-threaded manner
►CToolItem
CToolButtonItem	This class describes the properties of a 3ds Max custom toolbar button
CToolImageItem
CToolMacroItem
CToolOtherItem
CToolSeparatorItem
CToolStatusItem
Ctooltabentry
CToolTipExtender	Internal use only. Hidden internal implementation for ToolTipExtender
►CTrackClipObject
CNoteKeyClipObject
CTrackHitRecord
CTrackViewPick
CTranInfo
►CTransformer
CMoveTransformer
CRotateTransformer
CScaleTransformer
CSSChamferTransformer
CSSFilletTransformer
CSSOutlineTransformer
CSSSegBreakTransformer
CTransition
CTriStrip
CTVFace	This class is used for texture faces as well as vertex colors
►CTVNodeNotify
CUndoNotify
CTVPatch
CUTF8Str
CUtilityObj
CUVVertSet	This class represents the notion of a mesh edit UVW vertex assignment
►CUVWMapper
CUVWMapperDesc
CValueHolderMember
CVDataDelta
Cvector
CVEdge
CVertexBuffer	A vertex buffer, containing a Point3 and color
CVertexNormalsCallback
CVertexNormalsControl
CVertexShaderCache
CVertMove	This class represents the notion of a mesh edit vertex move
CViewFile	Class ViewFile
CViewWindowMetaData	Meta data of ViewWindow class; it contains the description of how the window is created
CWeekSchedule	Used by the Network Rendering API to store weekly scheduling information
CWireMeshData
CWStr
CXFormModes	This class contains a set of six command mode pointers that make up the XForm modes
CXTCContainer	This class represents a container class for XTCObjects
Cz_stream_s
CMAXScript_TLS
CMAXScriptPrefs
Cmbm_window
CMeshSubHitRec	This class allows access to the sub-object hit records used in Mesh hit testing
Cmessage_box_data
CMotionBlurSettings	Encapsulates the camera shutter settings used with motion blur
CMotionTransforms	Encapsulates motion transforms for an object
►CMSPlugin
CMSCustAttrib
►CMSPluginClass
CMSCustAttribDef
CMXS_Editor_Interface
Cmxs_notify_ref_data
Cmxs_value_id_pair
►CMXSEditor_Interface
CMXSEditor_Interface2
CMZPExtraction
CParamBlockData	Is a data structure for parameter blocks updates, used with events such as : EventType_Material_ParamBlock, EventType_Node_ParamBlock, ... All related to paramblocks updates
CParamBlockDesc
CParamBlockDescID
CIParamBlock2::ParameterIterator	Provides standard C++ iteration functionality for the parameters stored by an IParamBlock2
CIPhysicalCameraToneOperator::Parameters	The set of parameters used by the Physical Camera Exposure Control
CParamRef
Cparm_desc
CPB2Param
CIPerezAllWeather::PerezParams	Data structure for storing the ABCDE coefficients of the Perez sky model
CPointDataClass
CPointToPointPath
Cproperty_accessors
►CQDoubleSpinBox
►CQMaxFloatSpinBox	Qt Max spin box for float values
CQMaxLightingUnitSpinBox	Qt Max spin box for lighting units
CQMaxWorldSpinBox	Qt Max spin box for world units
►CQObject
CQMaxTranslationLoader
CQuery_Data_SO_Statistics
►CQWidget
CQMaxColorSwatch	Simple UI component to display and modify a color-value
CQMaxFloatSlider	Qt Max slider for float values
CQMaxParamBlockWidget	Base class for QWidgets which are to be controlled by a parameter block/map
►CRECT
CBox2
CRectangleSize	Struct that defines the width and height of one rectangle
►CRefObjectType
CSafeReferenceObjectProxy< RefObjectType >	This class is internally used for preventing the AddRef and Release of a pointer returned by RefPtr::operator -> from being called
CRenderNodeIterator	RenderNodeIterator is the iterator class to iterate all render nodes in the current render world
CIPhysicalCamera_BitmapApertureSampler::RGBValue	A simple RGB color value. the Max SDK's Color class couldn't be used since we want to remain independent from the rest of the Max SDK
Crollout_control
CScriptEditor
Csecondary
CSelectionIterator
CSinglePointerDestructor< Type >	DestructorPolicy template for pointer to single object types
Csrc_info
CStaticAssert< bool >	An assert that works at compile time
CStaticAssert< true >
CStrideArray< T >
CStrideArray< float >
CStrideArray< int >
CStrideArray< Point3 >
CStringConverter< char_type >
Csuperclass_table
►CT
CIFFDMod< T >
CTempBitmapManagerSilentMode
CTempQuietMode
CIMeshFlattener::TextureCoordChannel	Contains the vertex UVW coordinates for a single texture coordinate channel
CTHREADNAME_INFO
CTranslationResult	Encapsulates all of the possible result states for a translation operation
CTranslatorStatistics	Container for translation statistics
CUserCoord	A User definable Coordinate System
CUserGeneric
CUserProp
CUVTangentVectors	Return value of ComputeUVTangents()
CValueLoadCallback
CValueLoader
CValueMapper
CISunPositioner::WeatherMeasurements	Encapsulates weather measurements provided by a weather data file