// H to Pas Converter Ver.0.17.0.20
//     Date : 26 9 1999
//   Source : d3drmobj.h

unit d3drmobj;

{$X+}{$Z2}

interface

uses Windows, Ole2, d3drmdef, d3d, d3dtypes, ddraw;

(*==========================================================================;
 *
 *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       d3drm.h
 *  Content:    Direct3DRM include file
 *
 ***************************************************************************)

{$IFNDEF _D3DRMOBJ_H_}
{$DEFINE _D3DRMOBJ_H_}

// Error :  #include < objbase.h > (* Use Windows header files *)
{$DEFINE VIRTUAL}
// Error :  #include " d3drmdef.h "

// Error :  #include " d3d.h "

{$IFDEF __cplusplus}
// Error : extern "C" {
{$ENDIF}

(*
 * The methods for IUnknown
 *)
// Error :  #define IUNKNOWN_METHODS ( kind ) STDMETHOD ( QueryInterface ) ( THIS_ TIID riid , Pointer *ppvObj ) kind ; STDMETHOD_ ( ULONG , AddRef ) ( THIS ) kind ; STDMETHOD_ ( ULONG , Release ) ( THIS ) kind

(*
 * The methods for IDirect3DRMObject
 *)
// Error :  #define IDIRECT3DRMOBJECT_METHODS ( kind ) STDMETHOD ( Clone ) ( THIS_ LPUNKNOWN pUnkOuter , TIID riid , Pointer *ppvObj ) kind ; STDMETHOD ( AddDestroyCallback ) ( THIS_ D3DRMOBJECTCALLBACK , Pointer argument ) kind ; STDMETHOD ( DeleteDestroyCallback ) ( THIS_ D3DRMOBJECTCALLBACK , Pointer argument ) kind ; STDMETHOD ( SetAppData ) ( THIS_ DWORD data ) kind ; STDMETHOD_ ( DWORD , GetAppData ) ( THIS ) kind ; STDMETHOD ( SetName ) ( THIS_ LPCSTR ) kind ; STDMETHOD ( GetName ) ( THIS_ PWORD lpdwSize , LPSTR lpName ) kind ; STDMETHOD ( GetClassName ) ( THIS_ PWORD lpdwSize , LPSTR lpName ) kind


// Error :  #define WIN_TYPES ( itype , ptype ) typedef interface itype *LP##ptype , ** LPLP##ptype

//  IDirect3DRMObject  = ^DIRECT3DRMOBJECT;
//  LPDirect3DRMObject = ^IDirect3DRMObject;

// Error :   function WIN_TYPES( IDirect3DRMObject , DIRECT3DRMOBJECT ) ;
// Error :   function WIN_TYPES( IDirect3DRMObject2 , DIRECT3DRMOBJECT2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMDevice , DIRECT3DRMDEVICE ) ;
// Error :   function WIN_TYPES( IDirect3DRMDevice2 , DIRECT3DRMDEVICE2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMDevice3 , DIRECT3DRMDEVICE3 ) ;
// Error :   function WIN_TYPES( IDirect3DRMViewport , DIRECT3DRMVIEWPORT ) ;
// Error :   function WIN_TYPES( IDirect3DRMViewport2 , DIRECT3DRMVIEWPORT2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMFrame , DIRECT3DRMFRAME ) ;
// Error :   function WIN_TYPES( IDirect3DRMFrame2 , DIRECT3DRMFRAME2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMFrame3 , DIRECT3DRMFRAME3 ) ;
// Error :   function WIN_TYPES( IDirect3DRMVisual , DIRECT3DRMVISUAL ) ;
// Error :   function WIN_TYPES( IDirect3DRMMesh , DIRECT3DRMMESH ) ;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder , DIRECT3DRMMESHBUILDER ) ;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder2 , DIRECT3DRMMESHBUILDER2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder3 , DIRECT3DRMMESHBUILDER3 ) ;
// Error :   function WIN_TYPES( IDirect3DRMFace , DIRECT3DRMFACE ) ;
// Error :   function WIN_TYPES( IDirect3DRMFace2 , DIRECT3DRMFACE2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMLight , DIRECT3DRMLIGHT ) ;
// Error :   function WIN_TYPES( IDirect3DRMTexture , DIRECT3DRMTEXTURE ) ;
// Error :   function WIN_TYPES( IDirect3DRMTexture2 , DIRECT3DRMTEXTURE2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMTexture3 , DIRECT3DRMTEXTURE3 ) ;
// Error :   function WIN_TYPES( IDirect3DRMWrap , DIRECT3DRMWRAP ) ;
// Error :   function WIN_TYPES( IDirect3DRMMaterial , DIRECT3DRMMATERIAL ) ;
// Error :   function WIN_TYPES( IDirect3DRMMaterial2 , DIRECT3DRMMATERIAL2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMInterpolator , DIRECT3DRMINTERPOLATOR ) ;
// Error :   function WIN_TYPES( IDirect3DRMAnimation , DIRECT3DRMANIMATION ) ;
// Error :   function WIN_TYPES( IDirect3DRMAnimation2 , DIRECT3DRMANIMATION2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMAnimationSet , DIRECT3DRMANIMATIONSET ) ;
// Error :   function WIN_TYPES( IDirect3DRMAnimationSet2 , DIRECT3DRMANIMATIONSET2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMUserVisual , DIRECT3DRMUSERVISUAL ) ;
// Error :   function WIN_TYPES( IDirect3DRMShadow , DIRECT3DRMSHADOW ) ;
// Error :   function WIN_TYPES( IDirect3DRMShadow2 , DIRECT3DRMSHADOW2 ) ;
// Error :   function WIN_TYPES( IDirect3DRMArray , DIRECT3DRMARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMObjectArray , DIRECT3DRMOBJECTARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMDeviceArray , DIRECT3DRMDEVICEARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMFaceArray , DIRECT3DRMFACEARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMViewportArray , DIRECT3DRMVIEWPORTARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMFrameArray , DIRECT3DRMFRAMEARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMAnimationArray , DIRECT3DRMANIMATIONARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMVisualArray , DIRECT3DRMVISUALARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMPickedArray , DIRECT3DRMPICKEDARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMPicked2Array , DIRECT3DRMPICKED2ARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMLightArray , DIRECT3DRMLIGHTARRAY ) ;
// Error :   function WIN_TYPES( IDirect3DRMProgressiveMesh , DIRECT3DRMPROGRESSIVEMESH ) ;
// Error :   function WIN_TYPES( IDirect3DRMClippedVisual , DIRECT3DRMCLIPPEDVISUAL ) ;

(*
 * Direct3DRM Object classes
 *)
const
  CLSID_CDirect3DRMDevice: TGUID = (
    D1:$4fa3568e;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMViewport: TGUID = (
    D1:$4fa3568f;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMFrame: TGUID = (
    D1:$4fa35690;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMMesh: TGUID = (
    D1:$4fa35691;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMMeshBuilder: TGUID = (
    D1:$4fa35692;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMFace: TGUID = (
    D1:$4fa35693;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMLight: TGUID = (
    D1:$4fa35694;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMTexture: TGUID = (
    D1:$4fa35695;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMWrap: TGUID = (
    D1:$4fa35696;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMMaterial: TGUID = (
    D1:$4fa35697;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMAnimation: TGUID = (
    D1:$4fa35698;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMAnimationSet: TGUID = (
    D1:$4fa35699;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMUserVisual: TGUID = (
    D1:$4fa3569a;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMShadow: TGUID = (
    D1:$4fa3569b;D2:$623f;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  CLSID_CDirect3DRMViewportInterpolator: TGUID = (
    D1:$de9eaa1;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMFrameInterpolator: TGUID = (
    D1:$de9eaa2;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMMeshInterpolator: TGUID = (
    D1:$de9eaa3;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMLightInterpolator: TGUID = (
    D1:$de9eaa6;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMMaterialInterpolator: TGUID = (
    D1:$de9eaa7;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMTextureInterpolator: TGUID = (
    D1:$de9eaa8;D2:$3b84;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMProgressiveMesh: TGUID = (
    D1:$4516ec40;D2:$8f20;D3:$11d0;D4:($9b,$6d,$00,$00,$c0,$78,$1b,$c3));
  CLSID_CDirect3DRMClippedVisual: TGUID = (
    D1:$5434e72d;D2:$6d66;D3:$11d1;D4:($bb,$b,$0,$0,$f8,$75,$86,$5a));


(*
 * Direct3DRM Object interfaces
 *)
  IID_IDirect3DRMObject: TGUID = (
    D1:$eb16cb00;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMObject2: TGUID = (
    D1:$4516ec7c;D2:$8f20;D3:$11d0;D4:($9b,$6d,$00,$00,$c0,$78,$1b,$c3));
  IID_IDirect3DRMDevice: TGUID = (
    D1:$e9e19280;D2:$6e05;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMDevice2: TGUID = (
    D1:$4516ec78;D2:$8f20;D3:$11d0;D4:($9b,$6d,$00,$00,$c0,$78,$1b,$c3));
  IID_IDirect3DRMDevice3: TGUID = (
    D1:$549f498b;D2:$bfeb;D3:$11d1;D4:($8e,$d8,$0,$a0,$c9,$67,$a4,$82));
  IID_IDirect3DRMViewport: TGUID = (
    D1:$eb16cb02;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMViewport2: TGUID = (
    D1:$4a1b1be6;D2:$bfed;D3:$11d1;D4:($8e,$d8,$0,$a0,$c9,$67,$a4,$82));
  IID_IDirect3DRMFrame: TGUID = (
    D1:$eb16cb03;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMFrame2: TGUID = (
    D1:$c3dfbd60;D2:$3988;D3:$11d0;D4:($9e,$c2,$0,$0,$c0,$29,$1a,$c3));
  IID_IDirect3DRMFrame3: TGUID = (
    D1:$ff6b7f70;D2:$a40e;D3:$11d1;D4:($91,$f9,$0,$0,$f8,$75,$8e,$66));
  IID_IDirect3DRMVisual: TGUID = (
    D1:$eb16cb04;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMMesh: TGUID = (
    D1:$a3a80d01;D2:$6e12;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMMeshBuilder: TGUID = (
    D1:$a3a80d02;D2:$6e12;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMMeshBuilder2: TGUID = (
    D1:$4516ec77;D2:$8f20;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  IID_IDirect3DRMMeshBuilder3: TGUID = (
    D1:$4516ec82;D2:$8f20;D3:$11d0;D4:($9b,$6d,$00,$00,$c0,$78,$1b,$c3));
  IID_IDirect3DRMFace: TGUID = (
    D1:$eb16cb07;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMFace2: TGUID = (
    D1:$4516ec81;D2:$8f20;D3:$11d0;D4:($9b,$6d,$00,$00,$c0,$78,$1b,$c3));
  IID_IDirect3DRMLight: TGUID = (
    D1:$eb16cb08;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMTexture: TGUID = (
    D1:$eb16cb09;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMTexture2: TGUID = (
    D1:$120f30c0;D2:$1629;D3:$11d0;D4:($94,$1c,$0,$80,$c8,$c,$fa,$7b));
  IID_IDirect3DRMTexture3: TGUID = (
    D1:$ff6b7f73;D2:$a40e;D3:$11d1;D4:($91,$f9,$0,$0,$f8,$75,$8e,$66));
  IID_IDirect3DRMWrap: TGUID = (
    D1:$eb16cb0a;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMMaterial: TGUID = (
    D1:$eb16cb0b;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMMaterial2: TGUID = (
    D1:$ff6b7f75;D2:$a40e;D3:$11d1;D4:($91,$f9,$0,$0,$f8,$75,$8e,$66));
  IID_IDirect3DRMAnimation: TGUID = (
    D1:$eb16cb0d;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMAnimation2: TGUID = (
    D1:$ff6b7f77;D2:$a40e;D3:$11d1;D4:($91,$f9,$0,$0,$f8,$75,$8e,$66));
  IID_IDirect3DRMAnimationSet: TGUID = (
    D1:$eb16cb0e;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMAnimationSet2: TGUID = (
    D1:$ff6b7f79;D2:$a40e;D3:$11d1;D4:($91,$f9,$0,$0,$f8,$75,$8e,$66));
  IID_IDirect3DRMObjectArray: TGUID = (
    D1:$242f6bc2;D2:$3849;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  IID_IDirect3DRMDeviceArray: TGUID = (
    D1:$eb16cb10;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMViewportArray: TGUID = (
    D1:$eb16cb11;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMFrameArray: TGUID = (
    D1:$eb16cb12;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMVisualArray: TGUID = (
    D1:$eb16cb13;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMLightArray: TGUID = (
    D1:$eb16cb14;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMPickedArray: TGUID = (
    D1:$eb16cb16;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMFaceArray: TGUID = (
    D1:$eb16cb17;D2:$d271;D3:$11ce;D4:($ac,$48,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMAnimationArray: TGUID = (
    D1:$d5f1cae0;D2:$4bd7;D3:$11d1;D4:($b9,$74,$0,$60,$8,$3e,$45,$f3));
  IID_IDirect3DRMUserVisual: TGUID = (
    D1:$59163de0;D2:$6d43;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMShadow: TGUID = (
    D1:$af359780;D2:$6ba3;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1));
  IID_IDirect3DRMShadow2: TGUID = (
    D1:$86b44e25;D2:$9c82;D3:$11d1;D4:($bb,$b,$0,$a0,$c9,$81,$a0,$a6));
  IID_IDirect3DRMInterpolator: TGUID = (
    D1:$242f6bc1;D2:$3849;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  IID_IDirect3DRMProgressiveMesh: TGUID = (
    D1:$4516ec79;D2:$8f20;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  IID_IDirect3DRMPicked2Array: TGUID = (
    D1:$4516ec7b;D2:$8f20;D3:$11d0;D4:($9b,$6d,$0,$0,$c0,$78,$1b,$c3));
  IID_IDirect3DRMClippedVisual: TGUID = (
    D1:$5434e733;D2:$6d66;D3:$11d1;D4:($bb,$b,$0,$0,$f8,$75,$86,$5a));

type


  IDirect3DRMObject = class;
  LPDirect3DRMObject = IDirect3DRMObject;
  IDirect3DRMObject2 = class;
  LPDirect3DRMObject2 = IDirect3DRMObject2;
  IDirect3DRMDevice = class;
  LPDirect3DRMDevice = IDirect3DRMDevice;
  IDirect3DRMDevice2 = class;
  LPDirect3DRMDevice2 = IDirect3DRMDevice2;
// Error :   function WIN_TYPES( IDirect3DRMDevice2 , DIRECT3DRMDEVICE2 ) ;
  IDirect3DRMDevice3 = class;
  LPDirect3DRMDevice3 = IDirect3DRMDevice3;
// Error :   function WIN_TYPES( IDirect3DRMDevice3 , DIRECT3DRMDEVICE3 ) ;
  IDirect3DRMViewport = class;
  LPDirect3DRMViewport = IDirect3DRMViewport;
// Error :   function WIN_TYPES( IDirect3DRMViewport , DIRECT3DRMVIEWPORT ) ;
  IDirect3DRMViewport2 = class;
  LPDirect3DRMViewport2 = IDirect3DRMViewport2;
// Error :   function WIN_TYPES( IDirect3DRMViewport2 , DIRECT3DRMVIEWPORT2 ) ;
  IDirect3DRMFrame = class;
  LPDirect3DRMFrame = IDirect3DRMFrame;
// Error :   function WIN_TYPES( IDirect3DRMFrame , DIRECT3DRMFRAME ) ;
  IDirect3DRMFrame2 = class;
  LPDirect3DRMFrame2 = IDirect3DRMFrame2;
// Error :   function WIN_TYPES( IDirect3DRMFrame2 , DIRECT3DRMFRAME2 ) ;
  IDirect3DRMFrame3 = class;
  LPDirect3DRMFrame3 = IDirect3DRMFrame3;
// Error :   function WIN_TYPES( IDirect3DRMFrame3 , DIRECT3DRMFRAME3 ) ;
  IDirect3DRMVisual = class;
  LPDirect3DRMVisual = IDirect3DRMVisual;
// Error :   function WIN_TYPES( IDirect3DRMVisual , DIRECT3DRMVISUAL ) ;
  IDirect3DRMMesh = class;
  LPDirect3DRMMesh = IDirect3DRMMesh;
// Error :   function WIN_TYPES( IDirect3DRMMesh , DIRECT3DRMMESH ) ;
  IDirect3DRMMeshBuilder = class;
  LPDirect3DRMMeshBuilder = IDirect3DRMMeshBuilder;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder , DIRECT3DRMMESHBUILDER ) ;
  IDirect3DRMMeshBuilder2 = class;
  LPDirect3DRMMeshBuilder2 = IDirect3DRMMeshBuilder2;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder2 , DIRECT3DRMMESHBUILDER2 ) ;
  IDirect3DRMMeshBuilder3 = class;
  LPDirect3DRMMeshBuilder3 = IDirect3DRMMeshBuilder3;
// Error :   function WIN_TYPES( IDirect3DRMMeshBuilder3 , DIRECT3DRMMESHBUILDER3 ) ;
  IDirect3DRMFace = class;
  LPDirect3DRMFace = IDirect3DRMFace;
// Error :   function WIN_TYPES( IDirect3DRMFace , DIRECT3DRMFACE ) ;
  IDirect3DRMFace2 = class;
  LPDirect3DRMFace2 = IDirect3DRMFace2 ;
// Error :   function WIN_TYPES( IDirect3DRMFace2 , DIRECT3DRMFACE2 ) ;
  IDirect3DRMLight = class;
  LPDirect3DRMLight = IDirect3DRMLight ;
// Error :   function WIN_TYPES( IDirect3DRMLight , DIRECT3DRMLIGHT ) ;
  IDirect3DRMTexture = class;
  LPDirect3DRMTexture = IDirect3DRMTexture;
// Error :   function WIN_TYPES( IDirect3DRMTexture , DIRECT3DRMTEXTURE ) ;
  IDirect3DRMTexture2 = class;
  LPDirect3DRMTexture2 = IDirect3DRMTexture2;
// Error :   function WIN_TYPES( IDirect3DRMTexture2 , DIRECT3DRMTEXTURE2 ) ;
  IDirect3DRMTexture3 = class;
  LPDirect3DRMTexture3 = IDirect3DRMTexture3;
// Error :   function WIN_TYPES( IDirect3DRMTexture3 , DIRECT3DRMTEXTURE3 ) ;
  IDirect3DRMWrap = class;
  LPDirect3DRMWrap = IDirect3DRMWrap;
// Error :   function WIN_TYPES( IDirect3DRMWrap , DIRECT3DRMWRAP ) ;
  IDirect3DRMMaterial = class;
  LPDirect3DRMMaterial = IDirect3DRMMaterial;
// Error :   function WIN_TYPES( IDirect3DRMMaterial , DIRECT3DRMMATERIAL ) ;
  IDirect3DRMMaterial2 = class;
  LPDirect3DRMMaterial2 = IDirect3DRMMaterial2;
// Error :   function WIN_TYPES( IDirect3DRMMaterial2 , DIRECT3DRMMATERIAL2 ) ;
  IDirect3DRMInterpolator = class;
  LPDirect3DRMInterpolator = IDirect3DRMInterpolator;
// Error :   function WIN_TYPES( IDirect3DRMInterpolator , DIRECT3DRMINTERPOLATOR ) ;
  IDirect3DRMAnimation = class;
  LPDirect3DRMAnimation = IDirect3DRMAnimation;
// Error :   function WIN_TYPES( IDirect3DRMAnimation , DIRECT3DRMANIMATION ) ;
  IDirect3DRMAnimation2 = class;
  LPDirect3DRMAnimation2 = IDirect3DRMAnimation2;
// Error :   function WIN_TYPES( IDirect3DRMAnimation2 , DIRECT3DRMANIMATION2 ) ;
  IDirect3DRMAnimationSet = class;
  LPDirect3DRMAnimationSet = IDirect3DRMAnimationSet;
// Error :   function WIN_TYPES( IDirect3DRMAnimationSet , DIRECT3DRMANIMATIONSET ) ;
  IDirect3DRMAnimationSet2 = class;
  LPDirect3DRMAnimationSet2 = IDirect3DRMAnimationSet2;
// Error :   function WIN_TYPES( IDirect3DRMAnimationSet2 , DIRECT3DRMANIMATIONSET2 ) ;
  IDirect3DRMUserVisual = class;
  LPDirect3DRMUserVisual = IDirect3DRMUserVisual;
// Error :   function WIN_TYPES( IDirect3DRMUserVisual , DIRECT3DRMUSERVISUAL ) ;
  IDirect3DRMShadow = class;
  LPDirect3DRMShadow = IDirect3DRMShadow;
// Error :   function WIN_TYPES( IDirect3DRMShadow , DIRECT3DRMSHADOW ) ;
  IDirect3DRMShadow2 = class;
  LPDirect3DRMShadow2 = IDirect3DRMShadow2;
// Error :   function WIN_TYPES( IDirect3DRMShadow2 , DIRECT3DRMSHADOW2 ) ;
  IDirect3DRMArray = class;
  LPDirect3DRMArray = IDirect3DRMArray;
// Error :   function WIN_TYPES( IDirect3DRMArray , DIRECT3DRMARRAY ) ;
  IDirect3DRMObjectArray = class;
  LPDirect3DRMObjectArray = IDirect3DRMObjectArray;
// Error :   function WIN_TYPES( IDirect3DRMObjectArray , DIRECT3DRMOBJECTARRAY ) ;
  IDirect3DRMDeviceArray = class;
  LPDirect3DRMDeviceArray = IDirect3DRMDeviceArray;
// Error :   function WIN_TYPES( IDirect3DRMDeviceArray , DIRECT3DRMDEVICEARRAY ) ;
  IDirect3DRMFaceArray = class;
  LPDirect3DRMFaceArray = IDirect3DRMFaceArray;
// Error :   function WIN_TYPES( IDirect3DRMFaceArray , DIRECT3DRMFACEARRAY ) ;
  IDirect3DRMViewportArray = class;
  LPDirect3DRMViewportArray = IDirect3DRMViewportArray;
// Error :   function WIN_TYPES( IDirect3DRMViewportArray , DIRECT3DRMVIEWPORTARRAY ) ;
  IDirect3DRMFrameArray = class;
  LPDirect3DRMFrameArray = IDirect3DRMFrameArray;
// Error :   function WIN_TYPES( IDirect3DRMFrameArray , DIRECT3DRMFRAMEARRAY ) ;
  IDirect3DRMAnimationArray = class;
  LPDirect3DRMAnimationArray = IDirect3DRMAnimationArray;
// Error :   function WIN_TYPES( IDirect3DRMAnimationArray , DIRECT3DRMANIMATIONARRAY ) ;
  IDirect3DRMVisualArray = class;
  LPDirect3DRMVisualArray = IDirect3DRMVisualArray;
// Error :   function WIN_TYPES( IDirect3DRMVisualArray , DIRECT3DRMVISUALARRAY ) ;
  IDirect3DRMPickedArray = class;
  LPDirect3DRMPickedArray = IDirect3DRMPickedArray;
// Error :   function WIN_TYPES( IDirect3DRMPickedArray , DIRECT3DRMPICKEDARRAY ) ;
  IDirect3DRMPicked2Array = class;
  LPDirect3DRMPicked2Array = IDirect3DRMPicked2Array;
// Error :   function WIN_TYPES( IDirect3DRMPicked2Array , DIRECT3DRMPICKED2ARRAY ) ;
  IDirect3DRMLightArray = class;
  LPDirect3DRMLightArray = IDirect3DRMLightArray;
// Error :   function WIN_TYPES( IDirect3DRMLightArray , DIRECT3DRMLIGHTARRAY ) ;
  IDirect3DRMProgressiveMesh = class;
  LPDirect3DRMProgressiveMesh = IDirect3DRMProgressiveMesh;
// Error :   function WIN_TYPES( IDirect3DRMProgressiveMesh , DIRECT3DRMPROGRESSIVEMESH ) ;
  IDirect3DRMClippedVisual = class;
  LPDirect3DRMClippedVisual = IDirect3DRMClippedVisual;
// Error :   function WIN_TYPES( IDirect3DRMClippedVisual , DIRECT3DRMCLIPPEDVISUAL ) ;






  D3DRMOBJECTCALLBACK =   function (obj: LPDIRECT3DRMOBJECT; arg: Pointer): Pointer; stdcall;
  D3DRMFRAMEMOVECALLBACK =   function (obj: LPDIRECT3DRMFRAME; arg: Pointer; delta: D3DVALUE): Pointer; stdcall;
  D3DRMFRAME3MOVECALLBACK =   function (obj: LPDIRECT3DRMFRAME3; arg: Pointer;
	 delta: D3DVALUE): Pointer; stdcall;
  D3DRMUPDATECALLBACK =   function (obj: LPDIRECT3DRMDEVICE; arg: Pointer; Para0: Integer;
	 Para1: LPD3DRECT): Pointer; stdcall;
  D3DRMDEVICE3UPDATECALLBACK =   function (obj: LPDIRECT3DRMDEVICE3; arg: Pointer;
	 Para0: Integer; Para1: LPD3DRECT): Pointer; stdcall;
  D3DRMUSERVISUALCALLBACK =   function (obj: LPDIRECT3DRMUSERVISUAL; arg: Pointer;
	 reason: D3DRMUSERVISUALREASON; dev: LPDIRECT3DRMDEVICE; view: LPDIRECT3DRMVIEWPORT): PInteger; stdcall;
  D3DRMLOADTEXTURECALLBACK =   function (tex_name: PChar; arg: Pointer; var Para0: LPDIRECT3DRMTEXTURE): HRESULT; stdcall;
  D3DRMLOADTEXTURE3CALLBACK =   function (tex_name: PChar; arg: Pointer; var Para0: LPDIRECT3DRMTEXTURE3): HRESULT; stdcall;
  D3DRMLOADCALLBACK =   function (obj: LPDIRECT3DRMOBJECT; objectguid: TIID;
	 arg: Pointer): Pointer; stdcall;

  D3DRMDOWNSAMPLECALLBACK =   function (lpDirect3DRMTexture: LPDIRECT3DRMTEXTURE3;
	 pArg: Pointer; pDDSSrc: IDirectDrawSurface; pDDSDst: IDirectDrawSurface): HRESULT; stdcall;
  D3DRMVALIDATIONCALLBACK =   function (lpDirect3DRMTexture: LPDIRECT3DRMTEXTURE3;
	 pArg: Pointer; dwFlags: DWORD; dwcRects: DWORD; pRects: PRect): HRESULT; stdcall;


  LPD3DRMPICKDESC	= ^D3DRMPICKDESC;
  D3DRMPICKDESC = record
	ulFaceIdx	: ULONG;
	lGroupIdx	: LongInt;
	vPosition	: D3DVECTOR;

  end;

  LPD3DRMPICKDESC2	= ^D3DRMPICKDESC2;
  D3DRMPICKDESC2 = record
	ulFaceIdx	: ULONG;
	lGroupIdx	: LongInt;
	dvPosition	: D3DVECTOR;
	tu	: D3DVALUE;
	tv	: D3DVALUE;
	dvNormal	: D3DVECTOR;
	dcColor	: D3DCOLOR;

  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMObject

(*
 * Base class
 *)
  IDirect3DRMObject = class ( IUnknown )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;
    (* IDirec3DRMObject Methods *)
    function AddDestroyCallback(lpFunc: D3DRMOBJECTCALLBACK; pvArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function Clone(pUnkOuter: IUnknown; riid: TIID; var ppvObj: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteDestroyCallback(lpFunc: D3DRMOBJECTCALLBACK; pvArg: Pointer): HRESULT; virtual; stdcall; abstract;

    function SetAppData(data:DWord):HRESULT; virtual; stdcall; abstract;
    function GetAppData:DWord;  virtual; stdcall; abstract;
    function SetName(Para0:PChar):HRESULT;  virtual;stdcall;abstract;
    function GetName(lpdwSize:PDWord; lpName:PChar):HRESULT; virtual;stdcall;abstract;
    function GetClassName(lpdwSize:PDWord; lpName:PChar):HRESULT; virtual;stdcall;abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMObject2

  IDirect3DRMObject2= class ( IUnknown )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMObject2 methods
     *)
    function AddDestroyCallback(lpFunc: D3DRMOBJECTCALLBACK; pvArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function Clone(pUnkOuter: IUnknown; riid: TIID; var ppvObj: Pointer): HRESULT; virtual; stdcall; abstract;
    function GetDirect3DRM(var lplpDirect3DRM: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetName(lpdwSize: PWORD; lpName: LPSTR): HRESULT; virtual; stdcall; abstract;
    function SetClientData(dwID: DWORD; lpvData: Pointer; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetName(lpName: LPCSTR): HRESULT; virtual; stdcall; abstract;
    function GetAge(dwFlags: DWORD; pdwAge: PWORD): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMVisual

  IDirect3DRMVisual = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMDevice

  IDirect3DRMDevice = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMDevice methods
     *)
    function Init(width: ULONG; height: ULONG): HRESULT; virtual; stdcall; abstract;
    function InitFromD3D(lpD3D: IDirect3D; lpD3DDev: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;
    function InitFromClipper(lpDDClipper: IDirectDrawClipper; PGUID: PGUID; width: Integer;
	 height: Integer): HRESULT; virtual; stdcall; abstract;

    function Update: HRESULT; virtual; stdcall; abstract;
    function AddUpdateCallback(Para0: D3DRMUPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteUpdateCallback(Para0: D3DRMUPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function SetBufferCount(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetBufferCount: DWORD; virtual; stdcall; abstract;

    function SetDither(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetTextureQuality(Para0: D3DRMTEXTUREQUALITY): HRESULT; virtual; stdcall; abstract;

    function GetViewports(var return_views: LPDIRECT3DRMVIEWPORTARRAY): HRESULT; virtual; stdcall; abstract;

    function GetDither: BOOL; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetHeight: DWORD; virtual; stdcall; abstract;
    function GetWidth: DWORD; virtual; stdcall; abstract;
    function GetTrianglesDrawn: DWORD; virtual; stdcall; abstract;
    function GetWireframeOptions: DWORD; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetColorModel: D3DCOLORMODEL; virtual; stdcall; abstract;
    function GetTextureQuality: D3DRMTEXTUREQUALITY; virtual; stdcall; abstract;
    function GetDirect3DDevice(var Para0: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMDevice2

  IDirect3DRMDevice2 = class ( IDirect3DRMDevice )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMDevice methods
     *)
    {
    function Init(width: ULONG; height: ULONG): HRESULT; virtual; stdcall; abstract;
    function InitFromD3D(lpD3D: IDirect3D; lpD3DDev: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;
    function InitFromClipper(lpDDClipper: IDirectDrawClipper; PGUID: PGUID; width: Integer;
	 height: Integer): HRESULT; virtual; stdcall; abstract;

    function Update: HRESULT; virtual; stdcall; abstract;
    function AddUpdateCallback(Para0: D3DRMUPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteUpdateCallback(Para0: D3DRMUPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function SetBufferCount(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetBufferCount: DWORD; virtual; stdcall; abstract;

    function SetDither(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetTextureQuality(Para0: D3DRMTEXTUREQUALITY): HRESULT; virtual; stdcall; abstract;

    function GetViewports(var return_views: LPDIRECT3DRMVIEWPORTARRAY): HRESULT; virtual; stdcall; abstract;

    function GetDither: BOOL; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetHeight: DWORD; virtual; stdcall; abstract;
    function GetWidth: DWORD; virtual; stdcall; abstract;
    function GetTrianglesDrawn: DWORD; virtual; stdcall; abstract;
    function GetWireframeOptions: DWORD; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetColorModel: D3DCOLORMODEL; virtual; stdcall; abstract;
    function GetTextureQuality: D3DRMTEXTUREQUALITY; virtual; stdcall; abstract;
    function GetDirect3DDevice(var Para0: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;
    }
(*
     * IDirect3DRMDevice2 methods
     *)
    function InitFromD3D2(lpD3D: IDirect3D2; lpD3DDev: IDirect3DDevice2): HRESULT; virtual; stdcall; abstract;
    function InitFromSurface(PGUID: PGUID; lpDD: IDirectDraw; lpDDSBack: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function SetRenderMode(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetRenderMode: DWORD; virtual; stdcall; abstract;
    function GetDirect3DDevice2(var Para0: IDirect3DDevice2): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMDevice3

  IDirect3DRMDevice3 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMDevice methods
     *)
    function Init(width: ULONG; height: ULONG): HRESULT; virtual; stdcall; abstract;
    function InitFromD3D(lpD3D: IDirect3D; lpD3DDev: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;
    function InitFromClipper(lpDDClipper: IDirectDrawClipper; PGUID: PGUID; width: Integer; 
	 height: Integer): HRESULT; virtual; stdcall; abstract;

    function Update: HRESULT; virtual; stdcall; abstract;
    function AddUpdateCallback(Para0: D3DRMDEVICE3UPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteUpdateCallback(Para0: D3DRMDEVICE3UPDATECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function SetBufferCount(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetBufferCount: DWORD; virtual; stdcall; abstract;

    function SetDither(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetTextureQuality(Para0: D3DRMTEXTUREQUALITY): HRESULT; virtual; stdcall; abstract;

    function GetViewports(var return_views: LPDIRECT3DRMVIEWPORTARRAY): HRESULT; virtual; stdcall; abstract;

    function GetDither: BOOL; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetHeight: DWORD; virtual; stdcall; abstract;
    function GetWidth: DWORD; virtual; stdcall; abstract;
    function GetTrianglesDrawn: DWORD; virtual; stdcall; abstract;
    function GetWireframeOptions: DWORD; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetColorModel: D3DCOLORMODEL; virtual; stdcall; abstract;
    function GetTextureQuality: D3DRMTEXTUREQUALITY; virtual; stdcall; abstract;
    function GetDirect3DDevice(var Para0: IDirect3DDevice): HRESULT; virtual; stdcall; abstract;

(*
     * IDirect3DRMDevice2 methods
     *)
    function InitFromD3D2(lpD3D: IDirect3D2; lpD3DDev: IDirect3DDevice2): HRESULT; virtual; stdcall; abstract;
    function InitFromSurface(PGUID: PGUID; lpDD: IDirectDraw; lpDDSBack: IDirectDrawSurface; 
	 dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetRenderMode(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetRenderMode: DWORD; virtual; stdcall; abstract;
    function GetDirect3DDevice2(var Para0: IDirect3DDevice2): HRESULT; virtual; stdcall; abstract;

(*
     * IDirect3DRMDevice3 methods
     *)
    function FindPreferredTextureFormat(dwBitDepths: DWORD; dwFlags: DWORD; lpDDPF: LPDDPIXELFORMAT): HRESULT; virtual; stdcall; abstract;
    function RenderStateChange(drsType: D3DRENDERSTATETYPE; dwVal: DWORD; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function LightStateChange(drsType: D3DLIGHTSTATETYPE; dwVal: DWORD; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetStateChangeOptions(dwStateClass: DWORD; dwStateNum: DWORD; pdwFlags: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetStateChangeOptions(dwStateClass: DWORD; dwStateNum: DWORD; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
  end;


{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMViewport

  IDirect3DRMViewport = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMViewport methods
     *)
    function Init(dev: LPDIRECT3DRMDEVICE; camera: LPDIRECT3DRMFRAME; xpos: DWORD; 
	 ypos: DWORD; width: DWORD; height: DWORD): HRESULT; virtual; stdcall; abstract;
    function Clear: HRESULT; virtual; stdcall; abstract;
    function Render(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;

    function SetFront(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetBack(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetField(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetUniformScaling(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetCamera(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function SetProjection(Para0: D3DRMPROJECTIONTYPE): HRESULT; virtual; stdcall; abstract;
    function Transform(d: LPD3DRMVECTOR4D; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function InverseTransform(d: LPD3DVECTOR; s: LPD3DRMVECTOR4D): HRESULT; virtual; stdcall; abstract;
    function Configure(x: LongInt; y: LongInt; width: DWORD; height: DWORD): HRESULT; virtual; stdcall; abstract;
    function ForceUpdate(x1: DWORD; y1: DWORD; x2: DWORD; y2: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetPlane(left: D3DVALUE; right: D3DVALUE; bottom: D3DVALUE; top: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetCamera(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetDevice(var Para0: LPDIRECT3DRMDEVICE): HRESULT; virtual; stdcall; abstract;
    function GetPlane(var left: D3DVALUE; var right: D3DVALUE; var bottom: D3DVALUE; 
	 var top: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Pick(x: LongInt; y: LongInt; var return_visuals: LPDIRECT3DRMPICKEDARRAY): HRESULT; virtual; stdcall; abstract;

    function GetUniformScaling: BOOL; virtual; stdcall; abstract;
    function GetX: LongInt; virtual; stdcall; abstract;
    function GetY: LongInt; virtual; stdcall; abstract;
    function GetWidth: DWORD; virtual; stdcall; abstract;
    function GetHeight: DWORD; virtual; stdcall; abstract;
    function GetField: D3DVALUE; virtual; stdcall; abstract;
    function GetBack: D3DVALUE; virtual; stdcall; abstract;
    function GetFront: D3DVALUE; virtual; stdcall; abstract;
    function GetProjection: D3DRMPROJECTIONTYPE; virtual; stdcall; abstract;
    function GetDirect3DViewport(var Para0: IDirect3DViewport): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMViewport2
  IDirect3DRMViewport2 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMViewport2 methods
     *)
    function Init(dev: LPDIRECT3DRMDEVICE3; camera: LPDIRECT3DRMFRAME3; xpos: DWORD; 
	 ypos: DWORD; width: DWORD; height: DWORD): HRESULT; virtual; stdcall; abstract;
    function Clear(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function Render(Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;

    function SetFront(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetBack(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetField(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetUniformScaling(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetCamera(Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function SetProjection(Para0: D3DRMPROJECTIONTYPE): HRESULT; virtual; stdcall; abstract;
    function Transform(d: LPD3DRMVECTOR4D; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function InverseTransform(d: LPD3DVECTOR; s: LPD3DRMVECTOR4D): HRESULT; virtual; stdcall; abstract;
    function Configure(x: LongInt; y: LongInt; width: DWORD; height: DWORD): HRESULT; virtual; stdcall; abstract;
    function ForceUpdate(x1: DWORD; y1: DWORD; x2: DWORD; y2: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetPlane(left: D3DVALUE; right: D3DVALUE; bottom: D3DVALUE; top: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetCamera(var Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function GetDevice(var Para0: LPDIRECT3DRMDEVICE3): HRESULT; virtual; stdcall; abstract;
    function GetPlane(var left: D3DVALUE; var right: D3DVALUE; var bottom: D3DVALUE;
	 var top: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Pick(x: LongInt; y: LongInt; var return_visuals: LPDIRECT3DRMPICKEDARRAY): HRESULT; virtual; stdcall; abstract;

    function GetUniformScaling: BOOL; virtual; stdcall; abstract;
    function GetX: LongInt; virtual; stdcall; abstract;
    function GetY: LongInt; virtual; stdcall; abstract;
    function GetWidth: DWORD; virtual; stdcall; abstract;
    function GetHeight: DWORD; virtual; stdcall; abstract;
    function GetField: D3DVALUE; virtual; stdcall; abstract;
    function GetBack: D3DVALUE; virtual; stdcall; abstract;
    function GetFront: D3DVALUE; virtual; stdcall; abstract;
    function GetProjection: D3DRMPROJECTIONTYPE; virtual; stdcall; abstract;
    function GetDirect3DViewport(var Para0: IDirect3DViewport): HRESULT; virtual; stdcall; abstract;
    function TransformVectors(dwNumVectors: DWORD; lpDstVectors: LPD3DRMVECTOR4D; 
	 lpSrcVectors: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function InverseTransformVectors(dwNumVectors: DWORD; lpDstVectors: LPD3DVECTOR;
	 lpSrcVectors: LPD3DRMVECTOR4D): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFrame

  IDirect3DRMFrame = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMFrame methods
     *)
    function AddChild(child: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function AddLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function AddMoveCallback(Para0: D3DRMFRAMEMOVECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function AddTransform(Para0: D3DRMCOMBINETYPE; Para1: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function AddTranslation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddScale(Para0: D3DRMCOMBINETYPE; sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddRotation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE; 
	 theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVisual(Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function GetChildren(var children: LPDIRECT3DRMFRAMEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetLights(var lights: LPDIRECT3DRMLIGHTARRAY): HRESULT; virtual; stdcall; abstract;
    function GetMaterialMode: D3DRMMATERIALMODE; virtual; stdcall; abstract;
    function GetParent(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetPosition(reference: LPDIRECT3DRMFRAME; return_position: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetRotation(reference: LPDIRECT3DRMFRAME; axis: LPD3DVECTOR; return_theta: LPD3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetScene(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetSortMode: D3DRMSORTMODE; virtual; stdcall; abstract;
    function GetTexture(var Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function GetTransform(return_matrix: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function GetVelocity(reference: LPDIRECT3DRMFRAME; return_velocity: LPD3DVECTOR;
	 with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function GetOrientation(reference: LPDIRECT3DRMFRAME; dir: LPD3DVECTOR; up: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVisuals(var visuals: LPDIRECT3DRMVISUALARRAY): HRESULT; virtual; stdcall; abstract;
    function GetTextureTopology(wrap_u: PBOOL; wrap_v: PBOOL): HRESULT; virtual; stdcall; abstract;
    function InverseTransform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS; 
	 Para0: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function LookAt(target: LPDIRECT3DRMFRAME; reference: LPDIRECT3DRMFRAME; Para0: D3DRMFRAMECONSTRAINT): HRESULT; virtual; stdcall; abstract;
    function Move(delta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function DeleteChild(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function DeleteLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function DeleteMoveCallback(Para0: D3DRMFRAMEMOVECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteVisual(Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function GetSceneBackground: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneBackgroundDepth(var Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function GetSceneFogColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneFogEnable: BOOL; virtual; stdcall; abstract;
    function GetSceneFogMode: D3DRMFOGMODE; virtual; stdcall; abstract;
    function GetSceneFogParams(var return_start: D3DVALUE; var return_end: D3DVALUE; 
	 var return_density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackground(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundDepth(Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundImage(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogEnable(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogMode(Para0: D3DRMFOGMODE): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogParams(start: D3DVALUE; _end: D3DVALUE; density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetZbufferMode: D3DRMZBUFFERMODE; virtual; stdcall; abstract;
    function SetMaterialMode(Para0: D3DRMMATERIALMODE): HRESULT; virtual; stdcall; abstract;
    function SetOrientation(reference: LPDIRECT3DRMFRAME; dx: D3DVALUE; dy: D3DVALUE; 
	 dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; uz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetPosition(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetRotation(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSortMode(Para0: D3DRMSORTMODE): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetVelocity(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetZbufferMode(Para0: D3DRMZBUFFERMODE): HRESULT; virtual; stdcall; abstract;
    function Transform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFrame2

  IDirect3DRMFrame2 = class ( IDirect3DRMFrame )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMFrame methods
     *)
    {
    function AddChild(child: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function AddLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function AddMoveCallback(Para0: D3DRMFRAMEMOVECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function AddTransform(Para0: D3DRMCOMBINETYPE; Para1: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function AddTranslation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddScale(Para0: D3DRMCOMBINETYPE; sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddRotation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE; 
	 theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVisual(Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function GetChildren(var children: LPDIRECT3DRMFRAMEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetLights(var lights: LPDIRECT3DRMLIGHTARRAY): HRESULT; virtual; stdcall; abstract;
    function GetMaterialMode: D3DRMMATERIALMODE; virtual; stdcall; abstract;
    function GetParent(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetPosition(reference: LPDIRECT3DRMFRAME; return_position: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetRotation(reference: LPDIRECT3DRMFRAME; axis: LPD3DVECTOR; return_theta: LPD3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetScene(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetSortMode: D3DRMSORTMODE; virtual; stdcall; abstract;
    function GetTexture(var Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function GetTransform(return_matrix: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function GetVelocity(reference: LPDIRECT3DRMFRAME; return_velocity: LPD3DVECTOR; 
	 with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function GetOrientation(reference: LPDIRECT3DRMFRAME; dir: LPD3DVECTOR; up: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVisuals(var visuals: LPDIRECT3DRMVISUALARRAY): HRESULT; virtual; stdcall; abstract;
    function GetTextureTopology(wrap_u: PBOOL; wrap_v: PBOOL): HRESULT; virtual; stdcall; abstract;
    function InverseTransform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS; 
	 Para0: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function LookAt(target: LPDIRECT3DRMFRAME; reference: LPDIRECT3DRMFRAME; Para0: D3DRMFRAMECONSTRAINT): HRESULT; virtual; stdcall; abstract;
    function Move(delta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function DeleteChild(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function DeleteLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function DeleteMoveCallback(Para0: D3DRMFRAMEMOVECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteVisual(Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function GetSceneBackground: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneBackgroundDepth(var Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function GetSceneFogColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneFogEnable: BOOL; virtual; stdcall; abstract;
    function GetSceneFogMode: D3DRMFOGMODE; virtual; stdcall; abstract;
    function GetSceneFogParams(var return_start: D3DVALUE; var return_end: D3DVALUE;
	 var return_density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackground(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundDepth(Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundImage(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogEnable(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogMode(Para0: D3DRMFOGMODE): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogParams(start: D3DVALUE; _end: D3DVALUE; density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetZbufferMode: D3DRMZBUFFERMODE; virtual; stdcall; abstract;
    function SetMaterialMode(Para0: D3DRMMATERIALMODE): HRESULT; virtual; stdcall; abstract;
    function SetOrientation(reference: LPDIRECT3DRMFRAME; dx: D3DVALUE; dy: D3DVALUE; 
	 dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; uz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetPosition(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetRotation(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSortMode(Para0: D3DRMSORTMODE): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetVelocity(reference: LPDIRECT3DRMFRAME; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetZbufferMode(Para0: D3DRMZBUFFERMODE): HRESULT; virtual; stdcall; abstract;
    function Transform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    }
(*
     * IDirect3DRMFrame2 methods
     *)
    function AddMoveCallback2(Para0: D3DRMFRAMEMOVECALLBACK; arg: Pointer; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function GetBoxEnable: BOOL; virtual; stdcall; abstract;
    function GetAxes(dir: LPD3DVECTOR; up: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetMaterial(var Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function GetInheritAxes: BOOL; virtual; stdcall; abstract;
    function GetHierarchyBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;

    function SetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function SetBoxEnable(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetAxes(dx: D3DVALUE; dy: D3DVALUE; dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; 
	 uz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetInheritAxes(inherit_from_parent: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function SetQuaternion(reference: LPDIRECT3DRMFRAME; q: LPD3DRMQUATERNION): HRESULT; virtual; stdcall; abstract;

    function RayPick(reference: LPDIRECT3DRMFRAME; ray: LPD3DRMRAY; dwFlags: DWORD; 
	 var return_visuals: LPDIRECT3DRMPICKED2ARRAY): HRESULT; virtual; stdcall; abstract;
    function Save(filename: LPCSTR; d3dFormat: D3DRMXOFFORMAT; d3dSaveFlags: D3DRMSAVEOPTIONS): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFrame3

  IDirect3DRMFrame3 = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMFrame3 methods
     *)
    function AddChild(child: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function AddLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function AddMoveCallback(Para0: D3DRMFRAME3MOVECALLBACK; arg: Pointer; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function AddTransform(Para0: D3DRMCOMBINETYPE; Para1: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function AddTranslation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddScale(Para0: D3DRMCOMBINETYPE; sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddRotation(Para0: D3DRMCOMBINETYPE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE; 
	 theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVisual(Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetChildren(var children: LPDIRECT3DRMFRAMEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetLights(var lights: LPDIRECT3DRMLIGHTARRAY): HRESULT; virtual; stdcall; abstract;
    function GetMaterialMode: D3DRMMATERIALMODE; virtual; stdcall; abstract;
    function GetParent(var Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function GetPosition(reference: LPDIRECT3DRMFRAME3; return_position: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetRotation(reference: LPDIRECT3DRMFRAME3; axis: LPD3DVECTOR; return_theta: LPD3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetScene(var Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function GetSortMode: D3DRMSORTMODE; virtual; stdcall; abstract;
    function GetTexture(var Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function GetTransform(reference: LPDIRECT3DRMFRAME3; rmMatrix: LPD3DRMMATRIX4D): HRESULT; virtual; stdcall; abstract;
    function GetVelocity(reference: LPDIRECT3DRMFRAME3; return_velocity: LPD3DVECTOR;
	 with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function GetOrientation(reference: LPDIRECT3DRMFRAME3; dir: LPD3DVECTOR; up: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVisuals(lpdwCount: PWORD; var Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function InverseTransform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS; 
	 Para0: D3DRMLOADTEXTURE3CALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function LookAt(target: LPDIRECT3DRMFRAME3; reference: LPDIRECT3DRMFRAME3; 
	 Para0: D3DRMFRAMECONSTRAINT): HRESULT; virtual; stdcall; abstract;
    function Move(delta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function DeleteChild(Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function DeleteLight(Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function DeleteMoveCallback(Para0: D3DRMFRAME3MOVECALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
    function DeleteVisual(Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetSceneBackground: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneBackgroundDepth(var Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function GetSceneFogColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetSceneFogEnable: BOOL; virtual; stdcall; abstract;
    function GetSceneFogMode: D3DRMFOGMODE; virtual; stdcall; abstract;
    function GetSceneFogParams(var return_start: D3DVALUE; var return_end: D3DVALUE; 
	 var return_density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackground(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundDepth(Para0: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function SetSceneBackgroundImage(Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogEnable(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogMode(Para0: D3DRMFOGMODE): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogParams(start: D3DVALUE; _end: D3DVALUE; density: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetZbufferMode: D3DRMZBUFFERMODE; virtual; stdcall; abstract;
    function SetMaterialMode(Para0: D3DRMMATERIALMODE): HRESULT; virtual; stdcall; abstract;
    function SetOrientation(reference: LPDIRECT3DRMFRAME3; dx: D3DVALUE; dy: D3DVALUE; 
	 dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; uz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetPosition(reference: LPDIRECT3DRMFRAME3; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetRotation(reference: LPDIRECT3DRMFRAME3; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; theta: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSortMode(Para0: D3DRMSORTMODE): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function SetVelocity(reference: LPDIRECT3DRMFRAME3; x: D3DVALUE; y: D3DVALUE; 
	 z: D3DVALUE; with_rotation: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetZbufferMode(Para0: D3DRMZBUFFERMODE): HRESULT; virtual; stdcall; abstract;
    function Transform(d: LPD3DVECTOR; s: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function GetBoxEnable: BOOL; virtual; stdcall; abstract;
    function GetAxes(dir: LPD3DVECTOR; up: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetMaterial(var Para0: LPDIRECT3DRMMATERIAL2): HRESULT; virtual; stdcall; abstract;
    function GetInheritAxes: BOOL; virtual; stdcall; abstract;
    function GetHierarchyBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;

    function SetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function SetBoxEnable(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetAxes(dx: D3DVALUE; dy: D3DVALUE; dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; 
	 uz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetInheritAxes(inherit_from_parent: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL2): HRESULT; virtual; stdcall; abstract;
    function SetQuaternion(reference: LPDIRECT3DRMFRAME3; q: LPD3DRMQUATERNION): HRESULT; virtual; stdcall; abstract;

    function RayPick(reference: LPDIRECT3DRMFRAME3; ray: LPD3DRMRAY; dwFlags: DWORD; 
	 var return_visuals: LPDIRECT3DRMPICKED2ARRAY): HRESULT; virtual; stdcall; abstract;
    function Save(filename: LPCSTR; d3dFormat: D3DRMXOFFORMAT; d3dSaveFlags: D3DRMSAVEOPTIONS): HRESULT; virtual; stdcall; abstract;
    function TransformVectors(reference: LPDIRECT3DRMFRAME3; dwNumVectors: DWORD; 
	 lpDstVectors: LPD3DVECTOR; lpSrcVectors: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function InverseTransformVectors(reference: LPDIRECT3DRMFRAME3; dwNumVectors: DWORD; 
	 lpDstVectors: LPD3DVECTOR; lpSrcVectors: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function SetTraversalOptions(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetTraversalOptions(lpdwFlags: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetSceneFogMethod(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetSceneFogMethod(lpdwFlags: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetMaterialOverride(Para0: LPD3DRMMATERIALOVERRIDE): HRESULT; virtual; stdcall; abstract;
    function GetMaterialOverride(Para0: LPD3DRMMATERIALOVERRIDE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMesh

  IDirect3DRMMesh = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMesh methods
     *)
    function Scale(sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Translate(tx: D3DVALUE; ty: D3DVALUE; tz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function AddGroup(vCount: UINT; fCount: UINT; vPerFace: UINT; fData: PUINT; 
	 var returnId: D3DRMGROUPINDEX): HRESULT; virtual; stdcall; abstract;
    function SetVertices(id: D3DRMGROUPINDEX; index: UINT; count: UINT; values: LPD3DRMVERTEX): HRESULT; virtual; stdcall; abstract;
    function SetGroupColor(id: D3DRMGROUPINDEX; value: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetGroupColorRGB(id: D3DRMGROUPINDEX; red: D3DVALUE; green: D3DVALUE; 
	 blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetGroupMapping(id: D3DRMGROUPINDEX; value: D3DRMMAPPING): HRESULT; virtual; stdcall; abstract;
    function SetGroupQuality(id: D3DRMGROUPINDEX; value: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetGroupMaterial(id: D3DRMGROUPINDEX; value: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function SetGroupTexture(id: D3DRMGROUPINDEX; value: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;

    function GetGroupCount: Cardinal; virtual; stdcall; abstract;
    function GetGroup(id: D3DRMGROUPINDEX; vCount: PUINT; fCount: PUINT; vPerFace: PUINT;
	 fDataSize: PDWORD; fData: PUINT): HRESULT; virtual; stdcall; abstract;
    function GetVertices(id: D3DRMGROUPINDEX; index: DWORD; count: DWORD; returnPtr: LPD3DRMVERTEX): HRESULT; virtual; stdcall; abstract;
    function GetGroupColor(id: D3DRMGROUPINDEX): D3DCOLOR; virtual; stdcall; abstract;
    function GetGroupMapping(id: D3DRMGROUPINDEX): D3DRMMAPPING; virtual; stdcall; abstract;
    function GetGroupQuality(id: D3DRMGROUPINDEX): D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetGroupMaterial(id: D3DRMGROUPINDEX; var returnPtr: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function GetGroupTexture(id: D3DRMGROUPINDEX; var returnPtr: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMProgressiveMesh

  IDirect3DRMProgressiveMesh = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMProgressiveMesh methods
     *)
    function Load(lpObjLocation: Pointer; lpObjId: Pointer; dloLoadflags: D3DRMLOADOPTIONS; 
	 lpCallback: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function GetLoadStatus(lpStatus: LPD3DRMPMESHLOADSTATUS): HRESULT; virtual; stdcall; abstract;
    function SetMinRenderDetail(d3dVal: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Abort(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;

    function GetFaceDetail(lpdwCount: PWORD): HRESULT; virtual; stdcall; abstract;
    function GetVertexDetail(lpdwCount: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetFaceDetail(dwCount: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetVertexDetail(dwCount: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetFaceDetailRange(lpdwMin: PWORD; lpdwMax: PWORD): HRESULT; virtual; stdcall; abstract;
    function GetVertexDetailRange(lpdwMin: PWORD; lpdwMax: PWORD): HRESULT; virtual; stdcall; abstract;
    function GetDetail(var lpdvVal: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetDetail(d3dVal: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function RegisterEvents(hEvent: THandle; dwFlags: DWORD; dwReserved: DWORD): HRESULT; virtual; stdcall; abstract;
    function CreateMesh(var lplpD3DRMMesh: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    function Duplicate(var lplpD3DRMPMesh: LPDIRECT3DRMPROGRESSIVEMESH): HRESULT; virtual; stdcall; abstract;
    function GetBox(lpBBox: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function GetQuality(lpdwquality: LPD3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMShadow

  IDirect3DRMShadow = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMShadow methods
     *)
    function Init(visual: LPDIRECT3DRMVISUAL; light: LPDIRECT3DRMLIGHT; px: D3DVALUE;
	 py: D3DVALUE; pz: D3DVALUE; nx: D3DVALUE; ny: D3DVALUE; nz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMShadow2

  IDirect3DRMShadow2 = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMShadow methods
     *)
    function Init(pUNK: IUnknown; light: LPDIRECT3DRMLIGHT; px: D3DVALUE; py: D3DVALUE;
	 pz: D3DVALUE; nx: D3DVALUE; ny: D3DVALUE; nz: D3DVALUE): HRESULT; virtual; stdcall; abstract;

(*
     * IDirect3DRMShadow2 methods
     *)
    function GetVisual(var Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function SetVisual(pUNK: IUnknown; Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetLight(var Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
    function SetLight(Para0: LPDIRECT3DRMLIGHT; Para1: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetPlane(px: LPD3DVALUE; py: LPD3DVALUE; pz: LPD3DVALUE; nx: LPD3DVALUE;
	 ny: LPD3DVALUE; nz: LPD3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetPlane(px: D3DVALUE; py: D3DVALUE; pz: D3DVALUE; nx: D3DVALUE; ny: D3DVALUE;
	 nz: D3DVALUE; Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetOptions(Para0: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetOptions(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFace

  IDirect3DRMFace = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMFace methods
     *)
    function AddVertex(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVertexAndNormalIndexed(vertex: DWORD; normal: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(Para0: D3DVALUE; Para1: D3DVALUE; Para2: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetTextureCoordinates(vertex: DWORD; u: D3DVALUE; v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;

    function GetVertex(index: DWORD; vertex: LPD3DVECTOR; normal: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVertices(vertex_count: PDWORD; coords: LPD3DVECTOR; normals: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetTextureCoordinates(vertex: DWORD; var u: D3DVALUE; var v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetTextureTopology(wrap_u: PBOOL; wrap_v: PBOOL): HRESULT; virtual; stdcall; abstract;
    function GetNormal(Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetTexture(var Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function GetMaterial(var Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;

    function GetVertexCount: Integer; virtual; stdcall; abstract;
    function GetVertexIndex(which: DWORD): Integer; virtual; stdcall; abstract;
    function GetTextureCoordinateIndex(which: DWORD): Integer; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFace2

  IDirect3DRMFace2 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMFace methods
     *)
    function AddVertex(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVertexAndNormalIndexed(vertex: DWORD; normal: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(Para0: D3DVALUE; Para1: D3DVALUE; Para2: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function SetTextureCoordinates(vertex: DWORD; u: D3DVALUE; v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL2): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;

    function GetVertex(index: DWORD; vertex: LPD3DVECTOR; normal: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVertices(vertex_count: PDWORD; coords: LPD3DVECTOR; normals: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetTextureCoordinates(vertex: DWORD; var u: D3DVALUE; var v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetTextureTopology(wrap_u: PBOOL; wrap_v: PBOOL): HRESULT; virtual; stdcall; abstract;
    function GetNormal(Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetTexture(var Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function GetMaterial(var Para0: LPDIRECT3DRMMATERIAL2): HRESULT; virtual; stdcall; abstract;

    function GetVertexCount: Integer; virtual; stdcall; abstract;
    function GetVertexIndex(which: DWORD): Integer; virtual; stdcall; abstract;
    function GetTextureCoordinateIndex(which: DWORD): Integer; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMeshBuilder

  IDirect3DRMMeshBuilder = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMeshBuilder methods
     *)
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS;
	 Para0: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function Save(const filename: PChar; Para0: D3DRMXOFFORMAT; save: D3DRMSAVEOPTIONS): HRESULT; virtual; stdcall; abstract;
    function Scale(sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Translate(tx: D3DVALUE; ty: D3DVALUE; tz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColorSource(Para0: D3DRMCOLORSOURCE): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function GenerateNormals: HRESULT; virtual; stdcall; abstract;
    function GetColorSource: D3DRMCOLORSOURCE; virtual; stdcall; abstract;

    function AddMesh(Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    function AddMeshBuilder(Para0: LPDIRECT3DRMMESHBUILDER): HRESULT; virtual; stdcall; abstract;
    function AddFrame(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function AddFace(Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
    function AddFaces(vcount: DWORD; vertices: LPD3DVECTOR; ncount: DWORD; normals: LPD3DVECTOR; 
	 data: PDWORD; Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function ReserveSpace(vertex_Count: DWORD; normal_count: DWORD; face_count: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetPerspective(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetVertex(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetNormal(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetTextureCoordinates(index: DWORD; u: D3DVALUE; v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetVertexColor(index: DWORD; Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetVertexColorRGB(index: DWORD; red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetFaces(var Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetVertices(vcount: PDWORD; vertices: LPD3DVECTOR; ncount: PDWORD; 
	 normals: LPD3DVECTOR; face_data_size: PDWORD; face_data: PDWORD): HRESULT; virtual; stdcall; abstract;
    function GetTextureCoordinates(index: DWORD; var u: D3DVALUE; var v: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function AddVertex(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function AddNormal(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function CreateFace(var Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetPerspective: BOOL; virtual; stdcall; abstract;
    function GetFaceCount: Integer; virtual; stdcall; abstract;
    function GetVertexCount: Integer; virtual; stdcall; abstract;
    function GetVertexColor(index: DWORD): D3DCOLOR; virtual; stdcall; abstract;

    function CreateMesh(var Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMeshBuilder2

  IDirect3DRMMeshBuilder2 = class ( IDirect3DRMMeshBuilder )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMeshBuilder methods
     *)
    {
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS;
	 Para0: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function Save(const filename: PChar; Para0: D3DRMXOFFORMAT; save: D3DRMSAVEOPTIONS): HRESULT; virtual; stdcall; abstract;
    function Scale(sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Translate(tx: D3DVALUE; ty: D3DVALUE; tz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColorSource(Para0: D3DRMCOLORSOURCE): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function GenerateNormals: HRESULT; virtual; stdcall; abstract;
    function GetColorSource: D3DRMCOLORSOURCE; virtual; stdcall; abstract;

    function AddMesh(Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    function AddMeshBuilder(Para0: LPDIRECT3DRMMESHBUILDER): HRESULT; virtual; stdcall; abstract;
    function AddFrame(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function AddFace(Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
    function AddFaces(vcount: DWORD; vertices: LPD3DVECTOR; ncount: DWORD; normals: LPD3DVECTOR;
	 data: PDWORD; Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function ReserveSpace(vertex_Count: DWORD; normal_count: DWORD; face_count: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetPerspective(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetVertex(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetNormal(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetTextureCoordinates(index: DWORD; u: D3DVALUE; v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetVertexColor(index: DWORD; Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetVertexColorRGB(index: DWORD; red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetFaces(var Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetVertices(vcount: PDWORD; vertices: LPD3DVECTOR; ncount: PDWORD;
	 normals: LPD3DVECTOR; face_data_size: PDWORD; face_data: PDWORD): HRESULT; virtual; stdcall; abstract;
    function GetTextureCoordinates(index: DWORD; var u: D3DVALUE; var v: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function AddVertex(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function AddNormal(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function CreateFace(var Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetPerspective: BOOL; virtual; stdcall; abstract;
    function GetFaceCount: Integer; virtual; stdcall; abstract;
    function GetVertexCount: Integer; virtual; stdcall; abstract;
    function GetVertexColor(index: DWORD): D3DCOLOR; virtual; stdcall; abstract;

    function CreateMesh(var Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    }
(*
     * IDirect3DRMMeshBuilder2 methods
     *)
    function GenerateNormals2(crease: D3DVALUE; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetFace(index: DWORD; var Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMeshBuilder3

  IDirect3DRMMeshBuilder3 = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMeshBuilder3 methods
     *)
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS;
	 Para0: D3DRMLOADTEXTURE3CALLBACK; lpArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function Save(const filename: PChar; Para0: D3DRMXOFFORMAT; save: D3DRMSAVEOPTIONS): HRESULT; virtual; stdcall; abstract;
    function Scale(sx: D3DVALUE; sy: D3DVALUE; sz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Translate(tx: D3DVALUE; ty: D3DVALUE; tz: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColorSource(Para0: D3DRMCOLORSOURCE): HRESULT; virtual; stdcall; abstract;
    function GetBox(Para0: LPD3DRMBOX): HRESULT; virtual; stdcall; abstract;
    function GenerateNormals(crease: D3DVALUE; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetColorSource: D3DRMCOLORSOURCE; virtual; stdcall; abstract;

    function AddMesh(Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    function AddMeshBuilder(Para0: LPDIRECT3DRMMESHBUILDER3; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function AddFrame(Para0: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function AddFace(Para0: LPDIRECT3DRMFACE2): HRESULT; virtual; stdcall; abstract;
    function AddFaces(vcount: DWORD; vertices: LPD3DVECTOR; ncount: DWORD; normals: LPD3DVECTOR;
	 data: PDWORD; Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function ReserveSpace(vertex_Count: DWORD; normal_count: DWORD; face_count: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetTexture(Para0: LPDIRECT3DRMTEXTURE3): HRESULT; virtual; stdcall; abstract;
    function SetMaterial(Para0: LPDIRECT3DRMMATERIAL2): HRESULT; virtual; stdcall; abstract;
    function SetTextureTopology(wrap_u: BOOL; wrap_v: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetQuality(Para0: D3DRMRENDERQUALITY): HRESULT; virtual; stdcall; abstract;
    function SetPerspective(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetVertex(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetNormal(index: DWORD; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetTextureCoordinates(index: DWORD; u: D3DVALUE; v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetVertexColor(index: DWORD; Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetVertexColorRGB(index: DWORD; red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetFaces(var Para0: LPDIRECT3DRMFACEARRAY): HRESULT; virtual; stdcall; abstract;
    function GetGeometry(vcount: PDWORD; vertices: LPD3DVECTOR; ncount: PDWORD; 
	 normals: LPD3DVECTOR; face_data_size: PDWORD; face_data: PDWORD): HRESULT; virtual; stdcall; abstract;
    function GetTextureCoordinates(index: DWORD; var u: D3DVALUE; var v: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddVertex(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function AddNormal(x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): Integer; virtual; stdcall; abstract;
    function CreateFace(var Para0: LPDIRECT3DRMFACE2): HRESULT; virtual; stdcall; abstract;
    function GetQuality: D3DRMRENDERQUALITY; virtual; stdcall; abstract;
    function GetPerspective: BOOL; virtual; stdcall; abstract;
    function GetFaceCount: Integer; virtual; stdcall; abstract;
    function GetVertexCount: Integer; virtual; stdcall; abstract;
    function GetVertexColor(index: DWORD): D3DCOLOR; virtual; stdcall; abstract;
    function CreateMesh(var Para0: LPDIRECT3DRMMESH): HRESULT; virtual; stdcall; abstract;
    function GetFace(index: DWORD; var Para0: LPDIRECT3DRMFACE2): HRESULT; virtual; stdcall; abstract;
    function GetVertex(dwIndex: DWORD; lpVector: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetNormal(dwIndex: DWORD; lpVector: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function DeleteVertices(dwIndexFirst: DWORD; dwCount: DWORD): HRESULT; virtual; stdcall; abstract;
    function DeleteNormals(dwIndexFirst: DWORD; dwCount: DWORD): HRESULT; virtual; stdcall; abstract;
    function DeleteFace(Para0: LPDIRECT3DRMFACE2): HRESULT; virtual; stdcall; abstract;
    function Empty(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function Optimize(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function AddFacesIndexed(dwFlags: DWORD; lpdwvIndices: PDWORD; dwIndexFirst: PDWORD; 
	 dwCount: PDWORD): HRESULT; virtual; stdcall; abstract;
    function CreateSubMesh(var Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetParentMesh(Para0: DWORD; var Para1: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetSubMeshes(lpdwCount: PWORD; var Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function DeleteSubMesh(Para0: IUnknown): HRESULT; virtual; stdcall; abstract;
    function Enable(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetEnable(Para0: PDWORD): HRESULT; virtual; stdcall; abstract;
    function AddTriangles(dwFlags: DWORD; dwFormat: DWORD; dwVertexCount: DWORD; 
	 lpvData: Pointer): HRESULT; virtual; stdcall; abstract;
    function SetVertices(dwIndexFirst: DWORD; dwCount: DWORD; Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetVertices(dwIndexFirst: DWORD; lpdwCount: PWORD; Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function SetNormals(dwIndexFirst: DWORD; dwCount: DWORD; Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetNormals(dwIndexFirst: DWORD; lpdwCount: PWORD; Para0: LPD3DVECTOR): HRESULT; virtual; stdcall; abstract;
    function GetNormalCount: Integer; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMLight

  IDirect3DRMLight = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMLight methods
     *)
    function SetType(Para0: D3DRMLIGHTTYPE): HRESULT; virtual; stdcall; abstract;
    function SetColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;
    function SetColorRGB(red: D3DVALUE; green: D3DVALUE; blue: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetRange(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetUmbra(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetPenumbra(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetConstantAttenuation(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetLinearAttenuation(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetQuadraticAttenuation(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetRange: D3DVALUE; virtual; stdcall; abstract;
    function GetUmbra: D3DVALUE; virtual; stdcall; abstract;
    function GetPenumbra: D3DVALUE; virtual; stdcall; abstract;
    function GetConstantAttenuation: D3DVALUE; virtual; stdcall; abstract;
    function GetLinearAttenuation: D3DVALUE; virtual; stdcall; abstract;
    function GetQuadraticAttenuation: D3DVALUE; virtual; stdcall; abstract;
    function GetColor: D3DCOLOR; virtual; stdcall; abstract;
    function GetType: D3DRMLIGHTTYPE; virtual; stdcall; abstract;

    function SetEnableFrame(Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function GetEnableFrame(var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMTexture

  IDirect3DRMTexture = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMTexture methods
     *)
    function InitFromFile(const filename: PChar): HRESULT; virtual; stdcall; abstract;
    function InitFromSurface(lpDDS: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function InitFromResource(Para0: HRSRC): HRESULT; virtual; stdcall; abstract;
    function Changed(pixels: BOOL; palette: BOOL): HRESULT; virtual; stdcall; abstract;

    function SetColors(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalSize(width: D3DVALUE; height: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetDecalOrigin(x: LongInt; y: LongInt): HRESULT; virtual; stdcall; abstract;
    function SetDecalScale(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparency(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparentColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;

    function GetDecalSize(var width_return: D3DVALUE; var height_return: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetDecalOrigin(x_return: PLongint; y_return: PLongint): HRESULT; virtual; stdcall; abstract;

    function GetImage: LPD3DRMIMAGE; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetColors: DWORD; virtual; stdcall; abstract;
    function GetDecalScale: DWORD; virtual; stdcall; abstract;
    function GetDecalTransparency: BOOL; virtual; stdcall; abstract;
    function GetDecalTransparentColor: D3DCOLOR; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMTexture2

  IDirect3DRMTexture2 = class ( IDirect3DRMTexture )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMTexture methods
     *)
    {
    function InitFromFile(const filename: PChar): HRESULT; virtual; stdcall; abstract;
    function InitFromSurface(lpDDS: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function InitFromResource(Para0: HRSRC): HRESULT; virtual; stdcall; abstract;
    function Changed(pixels: BOOL; palette: BOOL): HRESULT; virtual; stdcall; abstract;

    function SetColors(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalSize(width: D3DVALUE; height: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetDecalOrigin(x: LongInt; y: LongInt): HRESULT; virtual; stdcall; abstract;
    function SetDecalScale(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparency(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparentColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;

    function GetDecalSize(var width_return: D3DVALUE; var height_return: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetDecalOrigin(x_return: PLongint; y_return: PLongint): HRESULT; virtual; stdcall; abstract;

    function GetImage: LPD3DRMIMAGE; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetColors: DWORD; virtual; stdcall; abstract;
    function GetDecalScale: DWORD; virtual; stdcall; abstract;
    function GetDecalTransparency: BOOL; virtual; stdcall; abstract;
    function GetDecalTransparentColor: D3DCOLOR; virtual; stdcall; abstract;
    }
(*
     * IDirect3DRMTexture2 methods
     *)
    function InitFromImage(Para0: LPD3DRMIMAGE): HRESULT; virtual; stdcall; abstract;
    function InitFromResource2(hModule: HMODULE; strName: PChar; strType: PChar): HRESULT; virtual; stdcall; abstract;
    function GenerateMIPMap(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMTexture3

  IDirect3DRMTexture3 = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMTexture3 methods
     *)
    function InitFromFile(const filename: PChar): HRESULT; virtual; stdcall; abstract;
    function InitFromSurface(lpDDS: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function InitFromResource(Para0: HRSRC): HRESULT; virtual; stdcall; abstract;
    function Changed(dwFlags: DWORD; dwcRects: DWORD; pRects: PRect): HRESULT; virtual; stdcall; abstract;
    function SetColors(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetShades(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalSize(width: D3DVALUE; height: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetDecalOrigin(x: LongInt; y: LongInt): HRESULT; virtual; stdcall; abstract;
    function SetDecalScale(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparency(Para0: BOOL): HRESULT; virtual; stdcall; abstract;
    function SetDecalTransparentColor(Para0: D3DCOLOR): HRESULT; virtual; stdcall; abstract;

    function GetDecalSize(var width_return: D3DVALUE; var height_return: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetDecalOrigin(x_return: PLongint; y_return: PLongint): HRESULT; virtual; stdcall; abstract;

    function GetImage: LPD3DRMIMAGE; virtual; stdcall; abstract;
    function GetShades: DWORD; virtual; stdcall; abstract;
    function GetColors: DWORD; virtual; stdcall; abstract;
    function GetDecalScale: DWORD; virtual; stdcall; abstract;
    function GetDecalTransparency: BOOL; virtual; stdcall; abstract;
    function GetDecalTransparentColor: D3DCOLOR; virtual; stdcall; abstract;
    function InitFromImage(Para0: LPD3DRMIMAGE): HRESULT; virtual; stdcall; abstract;
    function InitFromResource2(hModule: HMODULE; strName: PChar; strType: PChar): HRESULT; virtual; stdcall; abstract;
    function GenerateMIPMap(Para0: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetSurface(dwFlags: DWORD; var lplpDDS: IDirectDrawSurface): HRESULT; virtual; stdcall; abstract;
    function SetCacheOptions(lImportance: LongInt; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetCacheOptions(lplImportance: PLongint; lpdwFlags: PWORD): HRESULT; virtual; stdcall; abstract;
    function SetDownsampleCallback(pCallback: D3DRMDOWNSAMPLECALLBACK; pArg: Pointer): HRESULT; virtual; stdcall; abstract;
    function SetValidationCallback(pCallback: D3DRMVALIDATIONCALLBACK; pArg: Pointer): HRESULT; virtual; stdcall; abstract;
  end;


{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMWrap

  IDirect3DRMWrap = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMWrap methods
     *)
    function Init(Para0: D3DRMWRAPTYPE; ref: LPDIRECT3DRMFRAME; ox: D3DVALUE; oy: D3DVALUE; 
	 oz: D3DVALUE; dx: D3DVALUE; dy: D3DVALUE; dz: D3DVALUE; ux: D3DVALUE; uy: D3DVALUE; 
	 uz: D3DVALUE; ou: D3DVALUE; ov: D3DVALUE; su: D3DVALUE; sv: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function Apply(Para0: LPDIRECT3DRMOBJECT): HRESULT; virtual; stdcall; abstract;
    function ApplyRelative(frame: LPDIRECT3DRMFRAME; Para0: LPDIRECT3DRMOBJECT): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMaterial

  IDirect3DRMMaterial = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMaterial methods
     *)
    function SetPower(power: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSpecular(r: D3DVALUE; g: D3DVALUE; b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetEmissive(r: D3DVALUE; g: D3DVALUE; b: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetPower: D3DVALUE; virtual; stdcall; abstract;
    function GetSpecular(var r: D3DVALUE; var g: D3DVALUE; var b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetEmissive(var r: D3DVALUE; var g: D3DVALUE; var b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
  end;


{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMMaterial2

  IDirect3DRMMaterial2 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMMaterial2 methods
     *)
    function SetPower(power: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetSpecular(r: D3DVALUE; g: D3DVALUE; b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetEmissive(r: D3DVALUE; g: D3DVALUE; b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetPower: D3DVALUE; virtual; stdcall; abstract;
    function GetSpecular(var r: D3DVALUE; var g: D3DVALUE; var b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetEmissive(var r: D3DVALUE; var g: D3DVALUE; var b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetAmbient(var r: D3DVALUE; var g: D3DVALUE; var b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetAmbient(r: D3DVALUE; g: D3DVALUE; b: D3DVALUE): HRESULT; virtual; stdcall; abstract;
  end;


{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMAnimation

  IDirect3DRMAnimation = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMAnimation methods
     *)
    function SetOptions(flags: D3DRMANIMATIONOPTIONS): HRESULT; virtual; stdcall; abstract;
    function AddRotateKey(time: D3DVALUE; q: LPD3DRMQUATERNION): HRESULT; virtual; stdcall; abstract;
    function AddPositionKey(time: D3DVALUE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddScaleKey(time: D3DVALUE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function DeleteKey(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetFrame(frame: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function SetTime(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetOptions: D3DRMANIMATIONOPTIONS; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMAnimation2

  IDirect3DRMAnimation2 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMAnimation2 methods
     *)
    function SetOptions(flags: D3DRMANIMATIONOPTIONS): HRESULT; virtual; stdcall; abstract;
    function AddRotateKey(time: D3DVALUE; q: LPD3DRMQUATERNION): HRESULT; virtual; stdcall; abstract;
    function AddPositionKey(time: D3DVALUE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function AddScaleKey(time: D3DVALUE; x: D3DVALUE; y: D3DVALUE; z: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function DeleteKey(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function SetFrame(frame: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function SetTime(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;

    function GetOptions: D3DRMANIMATIONOPTIONS; virtual; stdcall; abstract;
    function GetFrame(var lpD3DFrame: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function DeleteKeyByID(dwID: DWORD): HRESULT; virtual; stdcall; abstract;
    function AddKey(lpKey: LPD3DRMANIMATIONKEY): HRESULT; virtual; stdcall; abstract;
    function ModifyKey(lpKey: LPD3DRMANIMATIONKEY): HRESULT; virtual; stdcall; abstract;
    function GetKeys(dvTimeMin: D3DVALUE; dvTimeMax: D3DVALUE; lpdwNumKeys: PWORD; 
	 lpKey: LPD3DRMANIMATIONKEY): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMAnimationSet

  IDirect3DRMAnimationSet = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMAnimationSet methods
     *)
    function AddAnimation(aid: LPDIRECT3DRMANIMATION): HRESULT; virtual; stdcall; abstract;
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS; 
	 Para0: D3DRMLOADTEXTURECALLBACK; lpArg: Pointer; parent: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
    function DeleteAnimation(aid: LPDIRECT3DRMANIMATION): HRESULT; virtual; stdcall; abstract;
    function SetTime(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMAnimationSet2

  IDirect3DRMAnimationSet2 = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMAnimationSet2 methods
     *)
    function AddAnimation(aid: LPDIRECT3DRMANIMATION2): HRESULT; virtual; stdcall; abstract;
    function Load(filename: Pointer; name: Pointer; loadflags: D3DRMLOADOPTIONS; 
	 Para0: D3DRMLOADTEXTURE3CALLBACK; lpArg: Pointer; parent: LPDIRECT3DRMFRAME3): HRESULT; virtual; stdcall; abstract;
    function DeleteAnimation(aid: LPDIRECT3DRMANIMATION2): HRESULT; virtual; stdcall; abstract;
    function SetTime(time: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetAnimations(var Para0: LPDIRECT3DRMANIMATIONARRAY): HRESULT; virtual; stdcall; abstract;
  end;


{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMUserVisual

  IDirect3DRMUserVisual = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMUserVisual methods
     *)
    function Init(fn: D3DRMUSERVISUALCALLBACK; arg: Pointer): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMArray

  IDirect3DRMArray = class ( IUnknown )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    //function GetSize: DWORD; virtual; stdcall; abstract;
(* No GetElement method as it would get overloaded
     * in derived classes, and overloading is
     * a no-no in COM
     *)
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMObjectArray

  IDirect3DRMObjectArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMOBJECT): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMDeviceArray

  IDirect3DRMDeviceArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMDEVICE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFrameArray

  IDirect3DRMFrameArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMFRAME): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMViewportArray

  IDirect3DRMViewportArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMVIEWPORT): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMVisualArray

  IDirect3DRMVisualArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMAnimationArray

  IDirect3DRMAnimationArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMANIMATION2): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMPickedArray

  IDirect3DRMPickedArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetPick(index: DWORD; var Para0: LPDIRECT3DRMVISUAL; var Para1: LPDIRECT3DRMFRAMEARRAY;
	 Para2: LPD3DRMPICKDESC): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMLightArray

  IDirect3DRMLightArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMLIGHT): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMFaceArray

  IDirect3DRMFaceArray = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetElement(index: DWORD; var Para0: LPDIRECT3DRMFACE): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMPicked2Array

  IDirect3DRMPicked2Array = class ( IDirect3DRMArray )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;

    function GetSize: DWORD; virtual; stdcall; abstract;
    function GetPick(index: DWORD; var Para0: LPDIRECT3DRMVISUAL; var Para1: LPDIRECT3DRMFRAMEARRAY;
	 Para2: LPD3DRMPICKDESC2): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMInterpolator

  IDirect3DRMInterpolator = class ( IDirect3DRMObject )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMInterpolator methods
     *)
    function AttachObject(Para0: LPDIRECT3DRMOBJECT): HRESULT; virtual; stdcall; abstract;
    function GetAttachedObjects(var Para0: LPDIRECT3DRMOBJECTARRAY): HRESULT; virtual; stdcall; abstract;
    function DetachObject(Para0: LPDIRECT3DRMOBJECT): HRESULT; virtual; stdcall; abstract;
    function SetIndex(Para0: D3DVALUE): HRESULT; virtual; stdcall; abstract;
    function GetIndex: D3DVALUE; virtual; stdcall; abstract;
    function Interpolate(Para0: D3DVALUE; Para1: LPDIRECT3DRMOBJECT; Para2: D3DRMINTERPOLATIONOPTIONS): HRESULT; virtual; stdcall; abstract;
  end;

{$UNDEF INTERFACE}
// Error :  #define INTERFACE IDirect3DRMClippedVisual

  IDirect3DRMClippedVisual = class ( IDirect3DRMVisual )
    //function IUNKNOWN_METHODS(Para0: PURE): Integer; stdcall;
    //function IDIRECT3DRMOBJECT_METHODS(Para0: PURE): Integer; stdcall;

(*
     * IDirect3DRMClippedVisual methods
     *)
    function Init(Para0: LPDIRECT3DRMVISUAL): HRESULT; virtual; stdcall; abstract;
    function AddPlane(Para0: LPDIRECT3DRMFRAME3; Para1: LPD3DVECTOR; Para2: LPD3DVECTOR;
	 Para3: DWORD; Para4: PWORD): HRESULT; virtual; stdcall; abstract;
    function DeletePlane(Para0: DWORD; Para1: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetPlaneIDs(Para0: PWORD; Para1: PWORD; Para2: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetPlane(Para0: DWORD; Para1: LPDIRECT3DRMFRAME3; Para2: LPD3DVECTOR;
	 Para3: LPD3DVECTOR; Para4: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetPlane(Para0: DWORD; Para1: LPDIRECT3DRMFRAME3; Para2: LPD3DVECTOR;
	 Para3: LPD3DVECTOR; Para4: DWORD): HRESULT; virtual; stdcall; abstract;
  end;

{$IFDEF __cplusplus}
// };
{$ENDIF}
{$ENDIF}(* _D3DRMOBJ_H_ *)


implementation

end.
