freddix a écrit :@Coolman :
A la base, je trouve DBPro très intéressant car facile. Mais la couche logicielle de gestion des structures du basic est trop lente .. Résultat j'utilise le purebasic [ qui est beaucoup + rapide
] pour appeler plusieurs fonctions de DBPro d'affilée et gagner du temps de calcul en zappant du coup la couche logicielle ... résultat mon frame rate est beaucoup + élevé [ presque 300% ] que le même moteur de jeu entièrement codé avec DBPro.
Maintenant, il y a DarkGameSDK qui est le moteur de DBPro mais sans la couche logicielle de gestion des structures du BASIC. DarkGame SDK est développé pour être utilisé en C++. Je suis en train de bosser sur l'adaptation de ses .LIB au purebasic car, grâce à cela, je garderais la simplicité de DBPro et cela entièrement intégré au purebasic
La, j'aurais mon moteur de jeu complet entièrement en purebasic sans avoir besoin de DBPro
Sinon pour notes sur d'autres messages du post que j'ai vu :
DBv1 = Langage interprété
DBPro = Langage COMPILE
C'est tres cool ca, donc il sera possible d'utiliser ta lib pour pureb sans posseder dbpro, est ce que ta lib sera opensource ou commercial ?
*******************************
J'ai egallement adapté mon premier test pour bcx :
Boucle Calcul Deux Variables 32000
Fois 1000 Fois De Suite
Dans L'ordre, Bcx -- Blitzbasic -- Purebasic
Boucle Calcul Deux Variables 32000
Fois 1000 Fois De Suite
CALCUL SUR DES NOMBRES ENTIERS
ADDITION : 92 -- 75 -- 809
SOUSTRACTION : 73 -- 75 -- 810
MULTIPLICATION : 75 -- 75 -- 855
DIVISION : 725 -- 744 -- 1196
CALCUL SUR DES NOMBRES REELS
ADDITION : 76 -- 213 -- 807
SOUSTRACTION : 72 -- 215 -- 809
MULTIPLICATION : 75 -- 219 -- 805
DIVISION : 525 -- 471 -- 930
Attention, pour purebasic, il ne faut pas tenir compte de ces resultas car le debug est activé. pour ibaspro, je l'ai desinstallé et je ne me rappelle pas vraiment les resultas en tous cas moins bon (deja posté)...
' *** CODE BCX ***
Code : Tout sélectionner
DIM Boucle%
DIM GloBoucle%
DIM res%
DIM V1%
DIM V2%
DIM DEB#
DIM FIN#
DIM CALC#
DIM res2#
DIM V12#
DIM V22#
DIM i%
DIM n%
Boucle% = 32000
GloBoucle% = 1000
Print "Boucle Calcul Deux Variables 32000"
Print "Fois 1000 Fois De Suite"
'-------------------------------------------------------------------------------
' CALCUL SUR LES ENTIERS
'
'****** MODULE TEST ********************************************************
Print
Print
Print "CALCUL SUR DES NOMBRES ENTIERS"
Print
res% = 0: V1% = 250: V2% = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res% = V1% + V2%
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "ADDITION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res% = 0: V1% = 250: V2% = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res% = V1% - V2%
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "SOUSTRACTION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res% = 0: V1% = 250: V2% = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res% = V1% * V2%
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "MULTIPLICATION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res% = 0: V1% = 250: V2% = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res% = V1% / V2%
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "DIVISION : "+Str$(CALC#)
'-------------------------------------------------------------------------------
' CALCUL SUR LES REELS
Print
Print
Print "CALCUL SUR DES NOMBRES REELS"
Print
res2# = 0: V12# = 250: V22# = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res2# = V12# + V22#
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "ADDITION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res2# = 0: V12# = 250: V22# = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res2# = V12# - V22#
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "SOUSTRACTION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res2# = 0: V12# = 250: V22# = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res2# = V12# * V22#
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "MULTIPLICATION : "+Str$(CALC#)
'****** MODULE TEST ********************************************************
res2# = 0: V12# = 250: V22# = 100
DEB# = TIMER
For n% = 1 To GloBoucle%
For i% = 1 To Boucle%
res2# = V12# / V22#
Next
Next
FIN# = TIMER
CALC# = int(FIN# - DEB#)
Print "DIVISION : "+Str$(CALC#)
While inkey$="" : Wend
End
*** Translaté En C ***
// *************************************************************
// Created with BCX -- The BASIC To C Translator (ver 4.76)
// BCX (c) 1999, 2000, 2001, 2002, 2003, 2004 by Kevin Diggins
// *************************************************************
// Translated for compiling using the Lcc-Win32 Compiler
// *************************************************************
#include <windows.h> // Win32 Header File
#include <windowsx.h> // Win32 Header File
#include <commctrl.h> // Win32 Header File
#include <mmsystem.h> // Win32 Header File
#include <shellapi.h> // Win32 Header File
#include <shlobj.h> // Win32 Header File
#include <richedit.h> // Win32 Header File
#include <wchar.h> // Win32 Header File
#include <objbase.h> // Win32 Header File
#include <ocidl.h> // Win32 Header File
#include <winuser.h> // Win32 Header File
#include <olectl.h> // Win32 Header File
#include <oaidl.h> // Win32 Header File
#include <ole2.h> // Win32 Header File
#include <oleauto.h> // Win32 Header File
#include <conio.h>
#include <direct.h>
#include <ctype.h>
#include <io.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <stdlib.h>
#include <setjmp.h>
#include <time.h>
#include <stdarg.h>
#include <process.h>
// *************************************************
// System Variables
// *************************************************
// *************************************************
// User Global Variables
// *************************************************
static int Boucle;
static int GloBoucle;
static int res;
static int V1;
static int V2;
static double DEB;
static double FIN;
static double CALC;
static double res2;
static double V12;
static double V22;
static int i;
static int n;
// *************************************************
// Standard Macros
// *************************************************
#define FINT(a)floor(a)
// *************************************************
// Standard Prototypes
// *************************************************
char* BCX_TmpStr(size_t);
char* str (double);
char* join (int, ... );
char* inkey (void);
float timer (void);
// *************************************************
// Main Program
// *************************************************
int main(int argc, char *argv[])
{
// *** CODE BCX ***
Boucle=32000;
GloBoucle=1000;
printf("%s\n","Boucle Calcul Deux Variables 32000");
printf("%s\n","Fois 1000 Fois De Suite");
// -------------------------------------------------------------------------------
// CALCUL SUR LES ENTIERS
//
// ****** MODULE TEST ********************************************************
printf("\n");
printf("\n");
printf("%s\n","CALCUL SUR DES NOMBRES ENTIERS");
printf("\n");
res=0;
V1=250;
V2=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res=V1+V2;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","ADDITION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res=0;
V1=250;
V2=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res=V1-V2;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","SOUSTRACTION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res=0;
V1=250;
V2=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res=V1*V2;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","MULTIPLICATION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res=0;
V1=250;
V2=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res=V1/V2;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","DIVISION : ",str( CALC ) );
// -------------------------------------------------------------------------------
// CALCUL SUR LES REELS
printf("\n");
printf("\n");
printf("%s\n","CALCUL SUR DES NOMBRES REELS");
printf("\n");
res2=0;
V12=250;
V22=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res2=V12+V22;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","ADDITION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res2=0;
V12=250;
V22=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res2=V12-V22;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","SOUSTRACTION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res2=0;
V12=250;
V22=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res2=V12*V22;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","MULTIPLICATION : ",str( CALC ) );
// ****** MODULE TEST ********************************************************
res2=0;
V12=250;
V22=100;
DEB=timer();
for(n=1; n<=GloBoucle; n+=1)
{
for(i=1; i<=Boucle; i+=1)
{
res2=V12/V22;
}
}
FIN=timer();
CALC=FINT(FIN-DEB);
printf("%s%s\n","DIVISION : ",str( CALC ) );
while(inkey()[0]==0)
{
}
fflush(stdout);
ExitProcess(0);
return 0; // End of main program
}
// *************************************************
// Run Time Functions
// *************************************************
char *BCX_TmpStr (size_t Bites)
{
static int StrCnt;
static char *StrFunc[2048];
StrCnt=(StrCnt + 1) & 2047;
if(StrFunc[StrCnt]) free (StrFunc[StrCnt]);
return StrFunc[StrCnt]=(char*)calloc(Bites+128,sizeof(char));
}
char *str (double d)
{
register char *strtmp = BCX_TmpStr(16);
sprintf(strtmp,"% .15G",d);
return strtmp;
}
char * join(int n, ...)
{
register int i = n, tmplen = 0;
register char *s_;
register char *strtmp = 0;
va_list marker;
va_start(marker, n); // Initialize variable arguments
while(i-- > 0)
{
s_ = va_arg(marker, char *);
tmplen += strlen(s_);
}
strtmp = BCX_TmpStr(tmplen);
va_end(marker); // Reset variable arguments
i = n;
va_start(marker, n); // Initialize variable arguments
while(i-- > 0)
{
s_ = va_arg(marker, char *);
strtmp = strcat(strtmp, s_);
}
va_end(marker); // Reset variable arguments
return strtmp;
}
char* inkey(void)
{
char *strtmp = BCX_TmpStr(2);
if (kbhit())
{
int asccodereturn = getch();
strtmp[0] = asccodereturn;
strtmp[1] = 0;
}
return strtmp;
}
float timer (void)
{
float tmp2;
int tmp;
tmp = GetTickCount();
tmp2 = tmp/1000.0;
return tmp;
}
, mais avant relis si c'est possible ce post...
