State of AmiDARK (Dark BASIC)

Basic 2D :
void DECls( void );
void DEInk( int ForeGroundcolor, int BackgroundColor );
void DEDot( int X, int Y );
void DEBox( int Left, int Top, int Right, int Bottom );
void DELine( int X1, int Y1, int X2, int Y2 );
void DECircle( int X, int Y, int Radius );
void DEElipse( int X, int Y, int XRadius, int YRadius );
int DERgb( int RedValue, int GreenValue, int BlueValue );
int DERgbR( int RGBColor );
int DERgbG( int RGBColor );
int DERgbB( int RGBColor );
int DEPoint( int X, int Y );
void DEDotEx( int X, int Y, int RGBColor );
void DEBoxEx( int Left, int Top, int Right, int Bottom, int Color1, int Color2, int Color3, int Color4 );
int DERGB( int RedValue, int GreenValue, int BlueValue );
int DERGBR( int RGBColor );
int DERGBG( int RGBColor );
int DERGBB( int RGBColor );
void DEEllipse( int X, int Y, int XRadius, int YRadius );
void DEClsEx( int ClearColor );
// Functions not available in DarkGDK 7.4 includes list //
void DESetYAxisToDefault( void );
void DEReverseYAxis( void );
// Added 2011.05.24 //
void DEDot3D( int X, int Y, int Z );
void DEDot3DEx( int X, int Y, int Z, int RGBColor );
void * DEGetPixelsPointer( void );
int DEGetPixelsPitch( void );
void DECopyArea( int iDextX, int iDestY, int iWidth, int iHeight, int iSourceX, int iSourceY );
int DEArgb( int AlphaValue, int RedValue, int GreenValue, int BlueValue );
int DEARGB( int AlphaValue, int RedValue, int GreenValue, int BlueValue );

Basic3D :
void DEMakeObjectBox( int ObjectID, float X, float Y, float Z );
void DEMakeObjectCube( int ObjectID, float Width );
void DEMakeObjectTriangle( int ObjectID, float X1, float Y1, float Z1, float X2, float Y2, float Z2, float X3, float Y3, float Z3 );
void DEMakeObjectPlain( int ObjectID, float Width, float Height );
void DEInstanceObject( int ObjectID, int SourceObject );
void DELoadObject( char * FileName, int ObjectID );
void DEDeleteObject( int ObjectID );
void DEDeleteObjects( int ObjectID1, int ObjectID2 );
void DEPositionObject( int ObjectID, float XPos, float YPos, float ZPos );
void DERotateObject( int ObjectID, float XRot, float YRot, float ZRot );
void DESetObjectRotationXYZ( int ObjectID );
void DESetObjectRotationZYX( int ObjectID );
void DEXRotateObject( int ObjectID, float XAngle );
void DEYRotateObject( int ObjectID, float YAngle );
void DEZRotateObject( int ObjectID, float ZAngle );
void DEScaleObject( int ObjectID, float XScaleF, float YScaleF, float ZScaleF );
int DEObjectExist( int ObjectID );
void DEFadeObject( int ObjectID, int FadeValue );
void DEGhostObjectOn( int ObjectID );
void DEGhostObjectOff( int ObjectID );
void DEGhostObjectOnEx( int ObjectID, int GhostEffect );
void DESetObject( int ObjectID, int WireFrame, int Transparent, int Cull );
void DESetObjectEx( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter );
void DESetObjectEx2( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light );
void DESetObjectEx3( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light, int Fog );
void DESetObjectEx4( int ObjectID, int WireFrame, int Transparent, int Cull, int Filter, int Light, int Fog, int Ambient );
void DESetObjectWireFrame( int ObjectID, int Flag );
void DESetObjectTransparency( int ObjectID, int flag );
void DESetObjectCull( int ObjectID, int flag );
void DESetObjectFilter( int ObjectID, int flag );
void DESetObjectFilterEx( int ObjectID, int flag, int Value );
void DESetObjectLight( int ObjectID, int flag );
void DESetObjectFog( int ObjectID, int flag );
void DESetObjectAmbient( int ObjectID, int flag );
void DESetObjectDiffuse( int ObjectID, int RGBColor );
void DESetObjectAmbience( int ObjectID, int RGBColor );
void DESetObjectSpecular( int ObjectID, int RGBColor );
void DESetObjectEmissive( int ObjectID, int RGBColor );
void DESetObjectSpecularPower( int ObjectID, int Power );
void DESetObjectDiffuseEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectAmbienceEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectSpecularEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectEmissiveEx( int ObjectID, int RGBRed, int RGBGreen, int RGBBlue );
void DESetObjectSpecularPower( int ObjectID, int Power );
void DESetAlphaMappingOn( int ObjectID, float AlphaPercentage );
void DEShowObject( int ObjectID );
void DEHideObject( int ObjectID );
void DEColorObjectEx( int ObjectID, int RGBR, int RGBG, int RGBB );
void DEColorObject( int ObjectID, int RGBColor );
int DEObjectExist( int ObjectID );
float DEObjectPositionX( int ObjectID );
float DEObjectPositionY( int ObjectID );
float DEObjectPositionZ( int ObjectID );
float DEObjectAngleX( int ObjectID );
float DEObjectAngleY( int ObjectID );
float DEObjectAngleZ( int ObjectID );
void DEEnableObjectZWrite( int ObjectID );
void DEDisableObjectZWrite( int ObjectID );
void DEDisableObjectBias( int iID );
void DEEnableObjectZBias( int iID, float fSlopeScale, float fDepth );
void DETextureObject( int ObjectID, int ImageID );
void DEScaleObjectTexture( int ObjectID, float UScale, float VScale );
void DEScrollObjectTexture( int ObjectID, float X, float Y );
int DEIsObjectAlpha( int ObjectID );
int DEIsObjectHidden( int ObjectID );
int DEIsObjectTransparent( int ObjectID );
void *DELimbPTR( int ObjectID, int LimbNumber );
void DERotateLimb( int ObjectID, int LimbNumber, float XAngle, float YAngle, float ZAngle );
void DEAddLimb( int ObjectID, int LimbNumber, int MeshNumber );
void DEHideLimb( int ObjectID, int LimbNumber );
void DELinkLimb( int ObjectID, int ParentLimb, int ChildLimb );
void DEOffsetLimb( int ObjectID, int LimbNumber, float X, float Y, float Z );
void DEScaleLimb( int ObjectID, int LimbNumber, float XSize, float YSize, float ZSize );
void DEScaleLimbTexture( int ObjectID, int LimbNumber, float UScale, float VScale );
void DEScrollLimbTexture( int ObjectID, int LimbNumber, float X, float Y );
void DEShowLimb( int ObjectID, int LimbNumber );
void DETextureLimb( int ObjectID, int LimbNumber, int ImageID );
int DECheckLimbLink( int ObjectID, int LimbNumber );
void DERemoveLimb( int ObjectID, int LimbNumber );
void DETextureLimbEx( int ObjectID, int LimbNumber, int StageNumber, int ImageID );
void DEColorLimb( int ObjectID, int LimbNumber, int RGBColor );
float DELimbAngleX( int ObjectID, int LimbNumber );
float DELimbAngleY( int ObjectID, int LimbNumber );
float DELimbAngleZ( int ObjectID, int LimbNumber );
int DELimbExist( int ObjectID, int LimbNumber );
float DELimbOffsetX( int ObjectID, int LimbNumber );
float DELimbOffsetY( int ObjectID, int LimbNumber );
float DELimbOffsetZ( int ObjectID, int LimbNumber );
float DELimbScaleX( int ObjectID, int LimbNumber );
float DELimbScaleY( int ObjectID, int LimbNumber );
float DELimbScaleZ( int ObjectID, int LimbNumber );
int DELimbTexture( int ObjectID, int LimbNumber );
float DELimbDirectionX( int ObjectID, int LimbNumber );
float DELimbDirectionY( int ObjectID, int LimbNumber );
float DELimbDirectionZ( int ObjectID, int LimbNumber );
float DELimbPositionX( int ObjectID, int LimbNumber );
float DELimbPositionY( int ObjectID, int LimbNumber );
float DELimbPositionZ( int ObjectID, int LimbNumber );
void * DEMeshPTR( int MeshNumber );
int DEMeshExist( int MeshNumber );
void DEMakeMeshFromObject( int MeshNumber, int ObjectID );
void DESaveMesh( char *FileName, int MeshNumber );
void DELoadMesh( char *FileName, int MeshNumber );
void DEDeleteMesh( int MeshNumber );
void DEChangeMesh( int ObjectID, int LimbNumber, int MeshNumber );
void DEMakeObject( int ObjectID, int MeshNumber, int ImageID );
int DENextFreeMesh( void );

Bitmap :
void DECreateBitmap( int iID, int iWidth, int iHeight );
void DEDeleteBitmap( int iID );
void DESetCurrentBitmap( int iID );
void DEFlipBitmap( int iID );
void DEMirrorBitmap( int iID );
BOOL DEBitmapExist( int iID );
int DEBitmapWidth( int iID );
int DEBitmapHeight( int iID );
int DEBitmapDepth( int iID );
int DEBitmapFlipped( int iID );
int DEBitmapMirror( int iID );
BOOL DEBitmapExistEx( void );
int DEBitmapWidthEx( void );
int DEBitmapHeightEx( void );
int DEBitmapDepthEx( void );
int DEBitmapFlippedEx( void );
int DEBitmapMirrorEx( void );
int DECurrentBitmap( void );
void DELoadBitmap( char* Filename, int BitmapID );
void DELoadBitmapEx( char* Filename );
void DECopyBitmap( int bSrc, int bTgt );
void DECopyBitmapEx( int bSrc, int iX1, int iY1, int iX2, int iY2, int bTgt, int iToX1, int iToY1, int iToX2, int iToY2 );
int DEGetBitmapWidth( int iID );
int DEGetBitmapHeight( int iID );
int DEGetBitmapDepth( int iID );

Camera3D :
void DEPositionCamera( float XPos, float YPos, float ZPos );
void DERotateCamera( float XAngle, float YAngle, float ZAngle );
void DEXRotateCamera( float XAngle );
void DEYRotateCamera( float YAngle );
void DEZRotateCamera( float ZAngle );
void DEPointCamera( float XPos, float YPos, float ZPos );
void DEMoveCamera( float Distance );
void DEMoveCameraLeft( float fStep );
void DEMoveCameraRight( float fStep );
void DEMoveCameraUp( float fStep );
void DEMoveCameraDown( float fStep );
void DESetCameraRange( int NearValue, int FarValue );
void DESetCameraView( int Left, int Top, int Right, int Bottom );
void DEClearCameraView( int RGBColor );
void DESetCameraRotationXYZ();
void DESetCameraRotationZYX();
void DESetCameraFov( float fieldOfViewAngle );
void DESetCameraAspect( float AspectRatio );
void DEAutocamON();
void DEAutocamOFF();
void DETurnCameraLeft( float AngleValue );
void DETurnCameraRight( float AngleValue );
void DEPitchCameraUp( float AngleValue );
void DEPitchCameraDown( float AngleValue );
void DERollCameraLeft( float AngleValue );
void DERollCameraRight( float AngleValue );
void SetCameraToObjectOrientation( int ObjectID );
void DEBackdropOn();
void DEBackdropOff();
void DEColorBackdrop( int RGBColor );
void DEColorBackdropEx( int CameraID, int RGBColor );
float DECameraPositionX() ;
float DECameraPositionY() ;
float DECameraPositionZ() ;
float DECameraAngleX() ;
float DECameraAngleY() ;
float DECameraAngleZ() ;
void DEMakeCamera( int CameraID );
void DEDeleteCamera( int CameraID );
void DESetCurrentCamera( int CameraID );
void DEMoveCameraLeftEx( int CameraID, float fStep );
void DEMoveCameraRightEx( int CameraID, float fStep );
void DEMoveCameraUpEx( int CameraID, float fStep );
void DEMoveCameraDownEx( int CameraID, float fStep );
void DEPositionCameraEx( int CameraID, float XPos, float YPos, float ZPos );
void DERotateCameraEx( int CameraID, float XAngle, float YAngle, float ZAngle );
void DEXRotateCameraEx( int CameraID, float XAngle );
void DEYRotateCameraEx( int CameraID, float YAngle );
void DEZRotateCameraEx( int CameraID, float ZAngle );
void DEPointCameraEx( int CameraID, float XPos, float YPos, float ZPos );
void DEMoveCameraEx( int CameraID, float Distance );
void DESetCameraRangeEx( int CameraID, float NearValue, float FarValue );
void DESetCameraViewEx( int CameraID, int Left, int Top, int Right, int Bottom );
void DEClearCameraViewEx( int CameraID, int RGBColor );
void DEClearCameraViewEx2( int CameraID, int iRed, int iGreen, int iBlue );
void DESetCameraRotationXYZEx( int CameraID );
void DESetCameraRotationZYXEx( int CameraID );
void DESetCameraFovEx( int CameraID, float FieldOfViewAngle );
void DESetCameraAspectEx( int CameraID, float AspectRatio );
void DETurnCameraLeftEx( int CameraID, float AngleValue );
void DETurnCameraRightEx( int CameraID, float AngleValue );
void DEPitchCameraUpEx( int CameraID, float AngleValue );
void DEPitchCameraDownEx( int CameraID, float AngleValue );
void DERollCameraLeftEx( int CameraID, float AngleValue );
void DERollCameraRightEx( int CameraID, float AngleValue );
void DESetCameraToObjectOrientationEx( int CameraID, int ObjectID );
void DEBackdropOnEx( int CameraID );
void DEBackdropOffEx( int CameraID );
void DEBackdropColorEx( int CameraID, int RGBColor );
float DECameraPositionXEx( int CameraID );
float DECameraPositionYEx( int CameraID );
float DECameraPositionZEx( int CameraID );
float DECameraAngleXEx( int CameraID );
float DECameraAngleYEx( int CameraID );
float DECameraAngleZEx( int CameraID );
int DECameraExist( int CameraID );

Core :
float DEWrapValue( float Angle );
float DEWrapValueEx( float Angle );
void DERandomize( int Value );
int DERnd( int RangeValue );
float DECos( float Angle );
float DESin( float Angle );
float DETan( float Angle );
float DEACos( float Angle );
float DEASin( float Angle );
float DEATan( float Angle );
float DEATanFull( float Value, float Value2 );
float DEHCos( float Value );
float DEHSin( float Value );
float DEHTan( float Value );
float DESqrt( float Value );
float DESqr( float Value );
float DEAbs( float Value );
Int Absolute Value */
int DEAbsI( int Value );
float DEInt( float Value );
float DEExp( float Value );
float DECOS( float Angle );
float DESIN( float Angle );
float DETAN( float Angle );
float DEACOS( float Angle );
float DEASIN( float Angle );
float DEATAN( float Angle );
float DEATANFULL( float Value, float Value2 );
float DEHCOS( float Value );
float DEHSIN( float Value );
float DEHTAN( float Value );
float DESQRT( float Value );
float DESQR( float Value );
float DEABS( float Value );
int DEABSI( int Value );
float DEINT( float Value );
float DEEXP( float Value );
float DECurveValue( float DestinationValue, float CurrentValue, float SpeedValue );
float DENewXValue( float CurrentXValue, float AngleValue, float StepValue );
float DENewYValue( float CurrentYValue, float AngleValue, float StepValue );
float DENewZValue( float CurrentZValue, float AngleValue, float StepValue );
float DECurveAngle( float DestinationValue, float CurrentValue, float SpeedValue );
void DESetCursor( int XPos, int YPos );
void DESyncON( void );
void DESyncOn( void );
void DESyncOFF( void );
void DESyncOff( void );
void DESyncRate( int Rate );
void DESyncMask( int dwMask );
void DESyncCamera( int CameraID );
void DESync();
void WaitForSynchro( void );
void DEPrint( char *ZeStr );
void DEDrawToBack( void );
void DEDrawToFront( void );
void DESpritesFirst( void );
void DESpritesLast( void );
void DESetDebugMode( int ModeID );
uint DETimer( void );
void DEBreak( void );
void DEEnableZTrick( void );
void DEDisableZTrick( void );
char * DEGetDate( void );
char * DEGetTime();
void DECopyMemory( void * MemoryDestination, void * MemorySource, int SizeInBytes );
void * DEMakeMemory( int SizeInBytes );
void DEDeleteMemory( void * MemoryAdress );
void DEFillMemory( void * MemoryAdress, BYTE FillByte, int SizeInBytes );
void DEAlwaysActiveOn( void );
void DEAlwaysActiveOff( void );
void DEWait( int Number );
void DESleep( int Number );
ULONG DEPerformanceTimer( void );
char * DEInKey( void );
void DEWaitKey( void );
void DESuspendForKey( void );
void DEWaitMouse( void );
void DESuspendForMouse( void );
void DEDisableSpritesBackdrop( void );
void DEEnableSpritesBackdrop( void );
char * DECl( void );
char * DEInput( char * iPut );
char * DEInputS( char * iPut );
int DEInputI( char * iPut );
float DEInputF( char * iPut );

File:
void DESetDir( char * pNewPath );
void DEFindFirst( void );
void DEFindNext( void );
void DEMakeFile( char * pFilename );
void DEDeleteFile( char* pFilename );
void DERenameFile( char* pOldFilename, char* pNewFilename );
void DECopyFile( char * pFilename, char * pFilename2 );
void DEMoveFile( char * pOldFilename, char * pNewFilename );
void DEWriteByteToFile( char* pFilename, int iPos, int iByte );
BYTE DEReadByteFromFile( char* pFilename, int iPos );
void DEMakeDirectory( char* pFilename );
void DEDeleteDirectory( char* pFilename );
void DEDeleteDirectory( char * pFilename );
BPTR DEExecuteExecutable( char * pName, char * pDirectory, char * pArguments );
BPTR DEExecuteExecutableEx( char * pName, char * pDirectory, char * pArguments, int pPriority );
void DEOpenToRead( int ChannelID, char *FileName );
void DEOpenToWrite( int ChannelID, char *FileName );
void DECloseFile( int ChannelID );
WORD DEReadWord( int ChannelID );
int DEReadFileI( int ChannelID );
float DEReadFloat( int ChannelID );
void *DEReadString( int ChannelID );
void DESkipBytes( int ChannelID, int iSkipvalue );
void DEWriteWord( int ChannelID, WORD ValueToInsert );
void DEWriteLong( int ChannelID, int ValueToInsert );
void DEWriteFloat( int ChannelID, float ValueToInsert );
void DEWriteString( int ChannelID, char * ValueToInsert );
void DEReadMemblock( int ChannelID, int MbcNumber );
void DEMakeMemblockFromFile( int ChannelID, int MbcNumber );
void DEWriteMemblock( int ChannelID, int MbcNumber );
void DEMakeFileFromMemblock( int ChannelID, int MbcNumber );
char * DEGetDir( void );
char * DEGetFileName( void );
int DEGetFileType( void );
char * DEGetFileDate( char * pFilename );
char * DEGetFileCreation( void );
int DEFileExist( char* pFilename );
int DEFileSize( int ChannelID );
int DEFileOpen( int FileID );
int DEFileEnd( int ChannelID );
void DECD( char * pNewPath );
BYTE DEReadByte( int ChannelID );
void DEWriteByte( int ChannelID, BYTE ValueToInsert );
int DEFileOpened( int FileID );
void DEFileOpenToRead( int ChannelID, char *FileName );
void DEFileOpenToWrite( int ChannelID, char *FileName );
void DEWriteToFile( int ChannelID, void *MemoryPointer, int BytesSize );
void DEReadFile( int ChannelID, void *MemoryPointer, int BytesSize );
int DEReadLong( int ChannelID );
int DEReadInt( int ChannelID );
void DEWriteInt( int ChannelID, int ValueToInsert );
void DEFileClose( int ChannelID );
int DENextFreeFile( void );
int DEGetFileSize( int ChannelID );
void DEMakeMemblockFromFileEx( int MemblockID, char *FileName );

Image 2D:
void DELoadImageEx( char * FileName, int ImageIndex, int ImageMode );
void DELoadImageResize( char* FileName, int iID, int TextureFlag, int iDivideTextureSize );
void DEGetImage( int ImageIndex, int iX1, int iY1, int iX2, int iY2 );
void DEGetImageEx( int ImageIndex, int iX1, int iY1, int iX2, int iY2, int iTextureFlag );
void DEPasteImageEx( int ImageIndex, int X, int Y, int Transparency );
void DEPasteImage( int ImageID, int X, int Y );
void DEDeleteImage( int ImageIndex );
int DEImageExist( int ImageIndex );
void DELoadImage( char * FileName, int ImageIndex );
void DESetImageColorKey( int Red, int Green, int Blue );
void DEGetImageData( int iID, uint * dwWidth, uint * dwHeight, uint * dwDepth, void * pData, uint * dwDataSize, BOOL bLockData );
void DESetImageData( int iID, uint dwWidth, uint dwHeight, uint dwDepth, void * pData, uint dwDataSize );
int DEGetImageExist( int iID );
char * DEGetImageName( int iID );
void DELockImage( int iID );
void DEUnlockImage( int iID );
void DEGetImageRGB( int iID, int iX, int iY, int * piR, int * piG, int * piB );
void DEWriteImageRGB( int iID, int iX, int iY, int piR, int piG, int piB );
void DESetImageMipmapMode( int iID, int bMode );
void DESetImageTranslucency( int iID, int iPercent );
void DEStretchImage( int iID, int iWidth, int iHeight );
int DEImageWidth( int ImageID );
int DEImageHeight( int ImageID );
BOOL DEImageFileExist( char * pFilename );
int DEImageExistEx( int ImageIndex );
void DEFlipImage( int ImageIndex );
void DEMirrorImage( int ImageIndex );

Input :
BOOL DEUpKey( void );
BOOL DEDownKey( void );
BOOL DELeftKey( void );
BOOL DERightKey( void );
BOOL DEControlKey( void );
BOOL DEShiftKey( void );
BOOL DESpaceKey( void );
BOOL DEEscapeKey( void );
BOOL DEReturnKey( void );
BOOL DEKeyState( int KeyID );
int DEScanCode( void );
int DEScancode( void );
int DEAScancode( void );
void DEHideMouse( void );
void DEShowMouse( void );
void DEPositionMouse( int XPos, int YPos );
void DEChangeMouse( int mSprite );
int DEMouseX( void );
int DEMouseY( void );
int DEMouseZ( void );
BOOL DEMouseClick( int MButton );
int DEMouseMoveX( void );
int DEMouseMoveY( void );
int DEMouseMoveZ( void );
BOOL DEJoystickUp( void );
BOOL DEJoystickDown( void );
BOOL DEJoystickLeft( void );
BOOL DEJoystickRight( void );
BOOL DEJoystickX( void );
BOOL DEJoystickY( void );
BOOL DEJoystickZ( void );
BOOL DEJoystickFireXL( int ButtonID );
BOOL DEJoystickFireA( void );
BOOL DEJoystickFireB( void );
BOOL DEJoystickFireC( void );
BOOL DEJoystickFireD( void );
int DEJoystickSliderA( void );
int DEJoystickSliderB( void );
int DEJoystickSliderC( void );
int DEJoystickSliderD( void );
int DEJoystickSliderX( void );
int DEJoystickSliderY( void );
int DEJoystickSliderZ( void );
int DEJoystickHatAngle( void );
void DEForceUp( int MagnitudeValue );
void DEForceDown( int MagnitudeValue );
void DEForceLeft( int MagnitudeValue );
void DEForceRight( int MagnitudeValue );
void DEForceAngle( int MagnitudeValue, int AngleValue, int DelayValue );
void DEForceChainSaw( int MagnitudeValue, int DelayValue );
void DEForceShoot( int MagnitudeValue, int DelayValue );
void DEForceImpact( int MagnitudeValue, int DelayValue );
void DEForceNoEffect( void );
void DEForceWaterEffect( int MagnitudeValue, int DelayValue );
void DEForceAutoCenterOn( void );
void DEForceAutoCenterOff( void );
int DEControlDeviceX( void );
int DEControlDeviceY( void );
int DEControlDeviceZ( void );
BOOL DEJoystickFireX( int ButtonID );
void DESetControlDevice( char * DeviceName );
void DESetControlDeviceEx( char * DeviceName, int DeviceIndex );
char * DEGetControlDevice( void );
BOOL DEGetKeyState( int KeyID );

Light3D :
void DEMakeLight( int LightID );
void DEDeleteLight( int LightID );
void DESetPointLight( int LightID, float X, float Y, float Z );
void DESetSpotLight( int LightID, float fInner, float fOuter );
void DESetDirectionalLight( int LightID, float NX, float NY, float NZ );
void DESetLightRange( int LightID, float LDistance );
void DEPositionLight( int LightID, float XPos, float YPos, float ZPos );
void DEHideLight( int LightID );
void DEShowLight( int LightID );
void DEColorLight( int LightID, int RGBColor );
void DEColorLightEx( int LightID, int RGBR, int RGBG, int RGBB );
void DESetNormalizationOn( void );
void DESetNormalizationOff( void );
void DESetAmbient( int Percent );
void DESetAmbientColor( int RGBColor );
void DEFogON( void );
void DEFogOFF( void );
void DEFogColor( int RGBValue );
void DEFogColorEx( int FRED, int FGREEN, int FBLUE );
void DEFogDistance( int Distance );
int DELightExist( int LightID );
int DELightType( int iID );
float DELightPositionX( int LightID );
float DELightPositionY( int LightID );
float DELightPositionZ( int LightID );
float DELightDirectionX( int LightID );
float DELightDirectionY( int LightID );
float DELightDirectionZ( int LightID );
float DELightRange( int LightID );
void DESetLightSpecular( int LightID, float fA, float fR, float fG, float fB );
void DESetLightAmbient( int LightID, float fA, float fR, float fG, float fB );
void DESetLightFalloff( int iID, float fValue );
void DESetLightAttenuation0( int iID, float fValue );
void DESetLightAttenuation1( int iID, float fValue );
void DESetLightAttenuation2( int iID, float fValue );
void DESetLightSpecularOn( void );
void DESetLightSpecularOff( void );
void DESetAmbientColorEx( int RGBR, int RGBG, int RGBB );
void DEFogStart( int FSTART );
void DEFogDensity( int FDENSITY );
void DEFogMode( int FMODE );
int DEGetAmbient( void );
int DEGetLightExist( int LightID );

Memblock :
void DEMakeMemblock( int MemblockID, int MBCSize );
void DEDeleteMemblock( int MemblockID );
int DEMemblockExist( int MemblockID );
void *DEGetMemblockPTR( int MemblockID );
int DEGetMemblockSize( int MemblockID );
void DECopyMemblock( int MBSource, int MBTarget, int PosSource, int PosTarget, int SizeToCopy );
void DEWriteMemblockByte( int MemblockID, int MemblockPOS, BYTE VALUE );
BYTE DEMemblockByte( int MemblockID, int MemblockPOS );
void DEWriteMemblockWord( int MemblockID, int MemblockPOS, WORD VALUE );
WORD DEMemblockWord( int MemblockID, int MemblockPOS );
void DEWriteMemblockDWord( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockDWord( int MemblockID, int MemblockPOS );
void DEWriteMemblockFloat( int MemblockID, int MemblockPOS, float VALUE );
float DEMemblockFloat( int MemblockID, int MemblockPOS );
void DEMakeMemblockFromBitmap( int mIndex, int bIndex );
void DEMakeBitmapFromMemblock( int bIndex, int mIndex );
void DEMakeMeshFromMemblock( int MeshID, int MemblockID );
void DEMakeMemblockFromMesh( int MemblockID, int MeshID );
void DEChangeMeshFromMemblock( int MeshID, int MemblockID );
void DEMakeMemblockFromImage( int MemblockID, int ImageID );
void DEMakeImageFromMemblock( int ImageID, int MemblockID );
int DENextFreeMemblock( void );
void DEWriteMemblockLong( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockLong( int MemblockID, int MemblockPOS );
void DEWriteMemblockInt( int MemblockID, int MemblockPOS, int VALUE );
int DEMemblockInt( int MemblockID, int MemblockPOS );

Music :
void DELoadMusic( char * FileName, int iID );
void DEDeleteMusic( int iID );
void DEPlayMusic( int iID );
void DEStopMusic( int iID );
void DEPauseMusic( int iID );
void DEResumeMusic( int iID );
void DESetMusicVolume( int iID, int iVolume );
int DEMusicExist( int iID );
int DEMusicPlaying( int iID );
int DEMusicLooping( int iID );
int DEMusicPaused( int iID );
int DEMusicVolume( int iID );

Setup :
int DEScreenFPS( void );
int DEEmulationMode( void );
int DEScreenDepth( void );
int DEScreenHeight( void );
int DEScreenWidth( void );
int DEScreenInvalid( void );
int DEScreenType( void );
void DESetDisplayMode( int Width, int Height, int Depth);
void DESetEmulationOn( void );
void DESetEmulationOff( void );
void DESetGamma( int GammaRed, int GammaGreen, int GammaBlue );
void DEShowWindow();
void DEHideWindow();
void DEMaximizeWindow( void );
void DEMinimizeWindow();
void DERestoreWindow( void );
void DESetWindowOn();
void DESetWindowOff();
void DESetWindowSize( int Width, int Height );
void DESetWindowPosition( int XPos, int YPos );
void DESetWindowTitle( char *WTitle );
void DEWindowToBack( void );
void DERefreshDoubleBufferOn( void );
void DERefreshDoubleBufferOff( void );

Sound :
void DELoadSound( char *szFilename, int iID );
void DEDeleteSound( int iID );
void DEPlaySound( int iID );
void DEStopSound( int iID );
void DEPauseSound( int iID );
void DEResumeSound( int iID );
void DESetSoundPan( int iID, int iPan );
void DESetSoundSpeed( int iID, int iSpeed );
void DESetSoundVolume( int iID, int iVolume );
int DESoundExist( int iID );
int DESoundType( int iID );
int DESoundPlaying( int iID );
int DESoundPaused( int iID );
int DESoundPan( int iID );
int DESoundSpeed( int iID );
int DESoundVolume( int iID );

Sprite2D :
void DESetSprite( int iID, int iBacksave, int iTransparent );
void DESprite( int iID, int iX, int iY, int iImage );
void DEHideSprite( int iID );
void DEShowSprite( int iID );
void DEHideAllSprites( void );
void DEShowAllSprites( void );
void DEDeleteSprite( int iID );
void DESetSpritePriority( int iID, float iPriority );
int DESpriteExist( int iID );
float DESpritePriority( int iID );
int DESpriteX( int iID );
int DESpriteY( int iID );
int DESpriteImage( int iID );
int DESpriteWidth( int iID );
int DESpriteHeight( int iID );
void DEPositionSprite( int iID, int iX, int iY );
void DESetSpriteX( int iID, int iX );
void DESetSpriteY( int iID, int iY );
int DESpriteMirrored( int iID );
int DESpriteFlipped( int iID );
void DEMirrorSprite( int iID );
void DEFlipSprite( int iID );
void DESetSpriteImage( int spriteID, int iID );
void DESetSpriteAlpha( int spriteID, int iID );
void DESetSpriteDiffuse( int spriteID, int RgbR, int RgbG, int RgbB );
void DESetSpriteTextureCoordinates( int iID, int iVertex, float tu, float tv );
void DESizeSprite( int iID, int iXSize, int iYSize );
void DEScaleSprite( int iID, float fScale );
int DESpriteScaleX( int iID);
int DESpriteScaleY( int iID);
void DEStretchSprite( int iID, int iXStretch, int iYStretch );
int DESpriteVisible( int iID );
int DESpriteRed( int iID );
int DESpriteGreen( int iID );
int DESpriteBlue( int iID );
int DESpriteAlpha( int iID );
void DECreateAnimatedSprite( int iID, char * szImage, int iWidth, int iHeight, int iImageID );
void DESetSpriteFrame( int iID, int iFrame );
void DEPlaySprite( int iID, int iStart, int iEnd, int iDelay );
int DESpriteFrame( int iID );
void DEOffsetSprite( int iID, int iXOffset, int iYOffset );
int DESpriteOffsetX( int iID );
int DESpriteOffsetY( int iID );
void DEPasteSprite( int iID, int iX, int iY );
void DEMoveSprite( int iID, float velocity );
void DERotateSprite( int iID, float fRotate );
void DECloneSprite( int iID, int iDestinationID );
int DESpriteHit( int iID, int iTarget );
int DESpriteCollision( int iID, int iTarget );
float DESpriteAngle( int iID );
void DESetSpriteTextureCoord( int iID, int iVertex, float tu, float tv );

System :
int DESystemTMEMAvailable( void );
int DESystemDMEMAvailable( void );
int DESystemSMEMAvailable( void );
int DESystemTmemAvailable( void );
int DESystemDmemAvailable( void );
int DESystemSmemAvailable( void );
void CopyMemory( void *MemBlockStart, int Size, void *MemBlockTarget );
void CopyMemoryMod( void * MemblockStart, int Width, int Height, int ModuloS, void * MemblockTarget, int ModuloT );
int BitTest( int Var, int BitID );
int TestBit( int Var, int BitID );
void SetBit( int *Var, int BitID );
void BitSet( int *Var, int BitID );
void ClearBit( int *Var, int BitID );
void BitClear( int *Var, int BitID );
void DEDisableEscapeKey( void );
void DEDisableEscapekey( void );
void DEEnableEscapeKey( void );
void DEEnableEscapekey( void );
void DEDisableSystemKeys( void );
void DEEnableSystemKeys( void );
void DEEmptyChecklist( void );
int DEChecklistQuantity( void );
int CheckListForValue( int iIndex );
int CheckListForString( int iIndex );
int DEChecklistValueA( int iIndex );
int DEChecklistValueB( int iIndex );
int DEChecklistValueC( int iIndex );
int DEChecklistValueD( int iIndex );
float DEChecklistFValueA( int iIndex );
float DEChecklistFValueB( int iIndex );
float DEChecklistFValueC( int iIndex );
float DEChecklistFValueD( int iIndex );
char* DEChecklistString( int iIndex );

Text :
int DEAsc( char * dwSrcStr );
char * DELeft(char * text, int num);
int DELen(char * text);
char * DELower(char * text);
char * DEMidEx(char * texta, int depart, int fin);
char * DEMid(char * texta, int depart);
char * DERight(char * texte, int num);
char * DEUpper(char * text);
char * DESpace(int num);
int DEVal( unsigned char *ZeChar );
char * DEFlip(char * Intext);
char * DEBin( int iValue );
char * DEHex( int iValue );
float DEValF( char * MyStr );
char * DEChr( int iValue );
char * DEStr( float fValue );
char * DEStrEx( float fValue, int iDecimal );
char * DEStrI( int iValue );
char * DEAppend( char * destination, char * source );
void DESetTextToNormal( void );
void DESetTextToItalic( void );
void DESetTextToBold( void );
void DESetTextToBoldItalic( void );
void DESetTextToOpaque( void );
void DESetTextToTransparent( void );
int DETextStyle( void );
int DETextBackgroundType( void );
void DESetTextOpaque( void );
void DESetTextTransparent( void );
void DESetTextSize( int tSize );
int DETextSize( void );
void DESetTextColor( int cAlpha, int cRed, int cGreen, int cBlue );
int DEGetTextColor( void );
void DEText( int xPos, int yPos, char* myText );
int DECompareCase( char * tInputA, char * tInputB );
void DEReverse( char * tInput );
int DEFindSubString( char * tSource, char * tString );
int DEFindFirstChar( char * tSource, char * tChar );
int DEFindLastChar( char * tSource, char * tChar );
void DESetTextFont( char* newFont );
char * DETextFont( void );
int DETextWidth( char * TextToCheck );
int DETextHeight( char * TextToCheck );
int DEGetTextWidth( char * TextToCheck );
int DEGetTextHeight( char * TextToCheck );
void DECenterText( int XPos, int YPos, char *ZeStr );

Vector :
float Distance3D( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );
float FindXAngle( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );
float FindYAngle( float X1, float Y1, float Z1, float X2, float Y2, float Z2 );