Login
Username:

Password:

Remember me



Lost Password?

Register now!

Sections

Who's Online
95 user(s) are online (53 user(s) are browsing Forums)

Members: 0
Guests: 95

more...

Headlines

Forum Index


Board index » All Posts (AmiDARK)




Re: No Games Software? No Games Software? ARE YOU MAD????
Quite a regular
Quite a regular


I also bought the DVD at the Alchemy (Alchimie in french).
Here are links where you can buy it :

https://acube-systemsbiz.serversicuro.it/shop/en/91-game-dvd-1.html
or
http://www.relec.ch/frch/index.php?pa ... rtuemart&Itemid=2&lang=fr (french only)

All we have to decide is what to do with the time that is given to us.
Go to top


Re: AmiDARK Engine & Alchimie X
Quite a regular
Quite a regular


@All : Thank you for your support :)
Be sure my health is the most important thing and my mental say "I don't want to be a victim of the "Electro Hyper Sensitivity" so, I'll make all my possible to recover ... It include to being exposed to check my actual state ;)

utri007 : effectively, The AmiDARK Engine is based on the same kind of commands than DarkBASIC Professionnal & DarkGDK however, in its actual state, it need to have all DarkGDK commands wrapped from dbXXXX naming convention to DEXXXX naming convention.

I plan to add some sort of "macro" to avoid to have to do this and to let AmiDARK Engine handle dbXXXX naming convention without need of changes.

All we have to decide is what to do with the time that is given to us.
Go to top


AmiDARK Engine & Alchimie X
Quite a regular
Quite a regular


Hi to all,

I think all of you know the details of my health problems I have now from a long time...
There is a month I got my Atlas vertebra ( the first vertebra ) replaced by a specialist... It was apparently dislocated since very long time ( perhaps since birth ) and seemed to be the source of some of my bad healths repercussions on my * physical body * .

Well I must admit that it makes now some weeks I feel much better ... Not yet at the top but I feel much better than six months ago...

I dreaded still a little Alchemy X at Tain l'Hermitage (France)... Why? Simply because many people with hardware and potentially mobile phones and wifi (so much electromagnetic waves) ...
Well it's been a long time that I can not exceed 20 or 30 minutes max in this kind of environment without suffering severe pain ...
Well there ... This was a test to see if the Atlas replacement makes things go better for me!
It's been a while since I was not in contact with high quantities of electromagnetic waves : (

Well ... ultimately ... what? ... Well those 3 days have gone very well !
Some pressure in the neck at some times ... Which required that I * make * the void in my mind and I try to clean ( in thought ) these pressure ....
However, no pain in the head! No feeling vise! No pain in the back! No electric pain in the limbs! Or physical exhaustion or eye strain!
What happiness! 3 days spent with people I really like ( I also took the opportunity to join the Triple A (on the idea and the advice of my wife : p )

I think I 'm in the process of " remission " and I hope to be completely recovered from the disease soonly. Electro Hyper sensitivity is usually very difficult to get out ...

As a result, I was able to move in and completely redo AmiDARK Engine system to become * Modular *. It will grantly help for the addition of plugin in the future. * it is the icing on the cake ... * for the evolution of the engine.
The engine now runs perfectly ( except for a small 3D lighting bug) in the new * Modular * form.
I'll fix this lighting bug , and probably change a few details to upload a new version of the AmiDARK 2D Engine as build 0.9 ( or 1.0 RC1 maybe, it will depend on the progress ) in the coming days ...

Thank you all for your support.

Sincerely,
AmiDARK.

All we have to decide is what to do with the time that is given to us.
Go to top


Re: CodeBench 0.42
Quite a regular
Quite a regular


Thank you Rigo for your new "CodeBench" release :)

All we have to decide is what to do with the time that is given to us.
Go to top


Re: Project "AmiDARK Engine" suspended.
Quite a regular
Quite a regular


Hi all and than you for your comments and support.
Be sure it's not a "definitive coming out".
It's just that emotionally and mentally, hard things happen and I cannot handle everything at the same time.
I must make "priorities" to resolve problems and then, when problems will be resolved, I hope to came back and continue my project.

All we have to decide is what to do with the time that is given to us.
Go to top


Project "AmiDARK Engine" suspended.
Quite a regular
Quite a regular


Hello everyone,

It's some sort of "bad news" I bring you there.
I'm a little forced to suspend * my * personal projects including Amiga ones for various reasons (job, financial, family, health) because a lot of these things are currently scrambling and make it becomes difficult to manage everything.

I will not expose all the details for you to avoid to write a full book 15 pages (those who really want to know will know but by private message), but despite all these, a small financial return recently (gain in law procedure for my wife) which saved us avoiding the worst, the situation is going down again, and I must do everything to avoid it ... Adding to this the other problems just outlined above.

So I have to take the time to refocus, on which is essential to manage, find solutions to these problems that are falling down on the corner of the mouth and, everything will be better. Then I hope to come back and continue this project important to my heart.

I wanted to inform you in respect to all the Amiga fans, because these latter times, no news about the project have been published.
I thank all those who have supported me so far.
And I tell you I hope ... soon.

@ +
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


Re: Ban the uploader
Quite a regular
Quite a regular


To Everyone,
Never forget that legally (and to give respect to the author), upload of software, even "freeware" is not legal if done without the agreement of the author.
Even if the author will not attack you using law concerning this fact, asking him for the agreement to do this is better.
Doing thing "too fast" always leads to mistakes and error!

All we have to decide is what to do with the time that is given to us.
Go to top


Re: Kebu
Quite a regular
Quite a regular


Really good musician :)
Thank you for this share.

All we have to decide is what to do with the time that is given to us.
Go to top


Re: AmigaAMP 3.7 with support of the TN plugin
Quite a regular
Quite a regular


Great news!

All we have to decide is what to do with the time that is given to us.
Go to top


Re: How to enable dma and set correct time?
Quite a regular
Quite a regular


Concerning DMA, I cannot help but concerning clock/time, I have found a small tool that get the correct date/clock from Internet and you can add it in the S:network-startup

it's yfacts on os4depot : http://www.os4depot.net/index.php?fun ... e=network/misc/yfacts.lha

Kindest Regards,
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


Re: WIP : AmiDARK Engine Rel 0.9 *Evolution*
Quite a regular
Quite a regular


@Nuder_Try : Thank you for your support.

@Kas1e : Probably but, I must admit that I didn't yet take time to search the net about free DarkBASIC(pro)&DarkGDK source code...

When release 0.9 will be out, I'll take some time for this task.

Kindest Regards,
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


WIP : AmiDARK Engine Rel 0.9 *Evolution*
Quite a regular
Quite a regular


Hello,

I create this subjecti to talk about the upcoming release 0.9 of the AmiDARK Engine.
It will probably be the last release before an eventual RC (Release Candidate) build concerning the 2D Only version of the GDK (Game Development Kit).

In this build are already available some changes and fixes that increase the whole engine however, before releasing this build 0.9, I'll have to make a major change in the engine.
This major upgrade will be to separate each module in a separate object file (.o) and, all these object files will be included inside the main library file (.a).

The interests with this major upgrade is double.

The first interest concern the final executable files. with that method, if you don't use a module, your C/C++ compiler shouldn't include the module object file (.o).
As an example, if you don't use the memblock module the memblock.o contained in the libAmiDARK.a library will not be included. Your executable will then be smaller of the size of the memblock.o file.

The second interest concern the upcoming feature for "additional modules" (plugins/TPC). On that principle, it will be easy to create an additional module for the AmiDARK Engine and this module can directly call the AmiDARK Engine commands and functions and, more to this, I can make this module to access some internal structure with the help of dedicaced functions. The objective of module is to allow the AmiDARK Engine to grow in functionalities and, according to this, a major upgrade will be made to the main "global refresh display" of the engine.
Currently, at each rendered frame, the engine work in this way :
- Render full 3D (only in 2D+3D version of the GDK)
- Render 2D images
- Get sprites background
- Display sprites
- Switch buffers and makes everything being displayed on screen
- Copy buffer to hidden one
- Refresh sprites background.
That order can be modified concerning 2D images and sprites using available commands but, to allow an "additional modules" that may have visual render to work, I must modify the whole function to handle two important features :
- The adding of new functions to be called during the "global refresh display" process, directly using their pointers.
- Adding a value for "render priority" to makes a module being drawn before another one to ensure things will be done in the good order.
These changes should allow in the near future, to add additional modules that can render to screen too and that will be entirely integrated in the main AmiDARK Engine "global refresh display" process.

All these changes will force me to rebuild some part of the engine so, the release of the 0.9 will be smally ... shifted to later. Of course, I'll keep you informed about the progress of these changes.

Don't forget that the AmiDARK Engine is a *personal* project without professional funcding. Then the project is developed during my free time and will depend on 2 major factors : My main work and my health.
These conditions makes the engine being developed slowly but piece per piece, the project evolce. I hope we'll soonly have a well working AmiDARK Engine GDK to help create video games and softwares under AmigaOS4.

Kindest Regards,
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


Re: http://hyperion-entertainment.biz hacked?
Quite a regular
Quite a regular


fake off ... Maybe mean it's a fake turn off of hyperion website ?
Maybe they prepare us something totally new and they're currently uploading the whole new websiteS ?

:p

All we have to decide is what to do with the time that is given to us.
Go to top


Re: State of AmiDARK (Dark BASIC)
Quite a regular
Quite a regular


Hello Atheist,

Here is the actual state of the AmiDARK Engine :
1. Version 2D Only of the engine is nearly finished. (contain everything excepted 3D engine, must add some more samples & docs/helps)
2. Version containing 3D is far from completion.
3. Project is *not* cancelled :p but due to health issue, it was really slowered these last months.

Commands amount :
2D Engine only : 476 commands on 484 planed.
(=Basic2D/Bitmap/Core/File/Image/Input/Memblock/Music/Setup/Sound/Sprite2D/System/Text)
Full Engine : 705 commands on 1137 planed.
(=2D Engine version + Basic3D/Camera3D/Light3D/Matrix3D/Vector3)

Don't forget that in it's actual state, the AmiDARK Engine is more like DarkGDK than like DarkBASIC Pro.
I must firstly finish the whole engine and then create an editor/interpreter to makes it work like DarkBASIC Professional.

Concerning the command list, you can find it in the AmiDARK Engine Includes files (and the help files) but, here are the actually *available* (and theorically running) commands/functions :
Quote:

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 );


I should release build 0.9 (2D Engine only) soonly.
Actual changes for 0.9 from 0.8 :

LATEST NEWS :
AMIGAOS4
- Fixed .cbp files to work correctly on any configurations where CodeBench is installed.
- Added missing .cbp files so all samples, Darkbasic demo, FX2D and technical projects own one.
- Fixed a bug in the AmigaOS4 makefiles (.aos4 files).
- Updated and optimised all AmigaOS4 makefiles.
- Created a script file for an automatic installation of the AmiDARK Engine.
BASIC2D
- Fixed a bug in the DECls & DEClsEx commands that caused flickering in fullscreen mode.
- Added a new sample that show how to draw triangles.
CORE
- Added a new sample that show the use of some of the CORE output functions.
IMAGE
- Removed some internal MiniGL GL_INVALID_ENUM.
SOUND
- Fixed a bug that prevented DEPlaySound from outputting audio.
TECHNICAL DEMONSTRATIONS
- Fixed the Raster demonstration by fixing the DECls command issue.

Known Issues in this release:
CORE
Functions DEGetDate & DEGetTime caused DSI Errors when using so they're actually empty functions. Should be fixed soonly.
SOUND
Functions DEPlaySound will not start sound again until it's previous playing is completed.


Kindest Regards,
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


Re: 2D Performances, what is best ? MiniGL ? Cairo ? Composition ? Intuition ?
Quite a regular
Quite a regular


Hello.

It really concern 2D Only stuffs! No primitives, blitting/copying image (memory areas)....

Thank you for all your answer.

Kindest Regards,
AmiDARK


Edited by AmiDARK on 2013/4/7 16:55:01
All we have to decide is what to do with the time that is given to us.
Go to top


2D Performances, what is best ? MiniGL ? Cairo ? Composition ? Intuition ?
Quite a regular
Quite a regular


Hello.

I'd like to know if someone has already made tests to compare 2D rendering performances between these 4 system on Amiga OS 4:
- Use MiniGL Primitives to render 2D.
- Use Cairo to render 2D
- Use Intuition Blitting to render 2D
- Use Composition mode.

What is the faster ?
What is the "most complete" in parameters, options and capabilities ?
And the average ?

Thank you.

Kindest Regards,
AmiDARK

All we have to decide is what to do with the time that is given to us.
Go to top


Re: *Urgent* Need help for audio datatype.
Quite a regular
Quite a regular


Thank you Salass00.
Will check this.

Kindest Regards,

All we have to decide is what to do with the time that is given to us.
Go to top


Re: Multitexturing in minigl/SDL?
Quite a regular
Quite a regular



All we have to decide is what to do with the time that is given to us.
Go to top


Re: *Urgent* Need help for audio datatype.
Quite a regular
Quite a regular


Hans,

As I said :
I've sent an e-mail to the author (his domain is now http://www.droolsoft.co.uk/ so his e-mail may be changed as the one in os4depot is wrong nog (it was previously .ltd.uk domain ... ) )

Already done ;)
Waiting for an answer.

All we have to decide is what to do with the time that is given to us.
Go to top


Re: Multitexturing in minigl/SDL?
Quite a regular
Quite a regular


Spirantho,
Multi texturing can be done under MiniGL.
I use it in the AmiDARK Engine for some special effects.

I use it this way :
Quote:

// 1st layer texture ( ID0 )
glActiveTexture(GL_TEXTURE0);
glEnable( GL_TEXTURE_2D );
UpdateMyImagePTR( ImageIndex );
TrueIndex = MyImagePTR->TrueImageIndex;
glBindTexture( GL_TEXTURE_2D, ImageTexture[ TrueIndex
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
...

...
// 2nd layer texture ( ID1 )
glActiveTexture(GL_TEXTURE1);
glEnable( GL_TEXTURE_2D );
UpdateMyImagePTR( mRaster[ RasterID ].iRaster );
TrueIndex = MyImagePTR->TrueImageIndex;
glBindTexture( GL_TEXTURE_2D, ImageTexture[ TrueIndex ] );
...

...
// Mix the two textures.
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD); //Add RGB with RGB
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
//------------------------
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_ADD); //Add ALPHA with ALPHA
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
...

...
// Render
glBegin( GL_QUADS );
glMultiTexCoord2f( GL_TEXTURE0, tcx1, tcy1 ); // Top-Left
glMultiTexCoord2f( GL_TEXTURE1, 0.0, yrp1 ); // Top-Left yrp1
glVertex2f( (float)xf1, (float)yf1 );
glMultiTexCoord2f( GL_TEXTURE0, tcx2, tcy1 ); // Top-Right
glMultiTexCoord2f( GL_TEXTURE1, 1.0, yrp1 ); // Top-Right yrp1
glVertex2f( (float)xf2, (float)yf1 );
glMultiTexCoord2f( GL_TEXTURE0, tcx2, tcy2 ); // Bottom-Right
glMultiTexCoord2f( GL_TEXTURE1, 1.0, yrp2 ); // Bottom-Right yrp2
glVertex2f( (float)xf2, (float)yf2 );
glMultiTexCoord2f( GL_TEXTURE0, tcx1, tcy2 ); // Bottom-Left
glMultiTexCoord2f( GL_TEXTURE1, 0.0, yrp2 ); // Bottom-Left yrp2
glVertex2f( (float)xf1, (float)yf2 );
glEnd();


And it works perfectly.

Concerning SDL ... I don't know.

Kindest Regards,
AmiDARK


Edited by AmiDARK on 2013/3/3 16:35:46
All we have to decide is what to do with the time that is given to us.
Go to top



TopTop
« 1 2 (3) 4 5 6 ... 37 »




Powered by XOOPS 2.0 © 2001-2023 The XOOPS Project