Bonjour, - bien heureux que tout soir rentre ds l'orde, bravo et merci -

voici un bout de code :


void DrawSphere(unsigned short x, unsigned short y, unsigned int r, float phase, float angle)
{
float xa = 0.0,
ya = 0.0,
za = 0.0;
unsigned int xs = 0,
xx = 0,
ys = 0,
yy = 0;
float a = 0.0,
b = 0.0,
j = 0.0;

for( a=-PI/2.0 ; a<PI/2.0 ; a+=0.2)
{
if(phase>PI)
{
b=phase-PI; //Deg2Rad(Norm180(Rad2Deg(phase-PI)));
j=PI;
}
else
{
b=0.0;
j=phase;
}
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*angle));
ys = (unsigned int)Int_Float(za+ya*angle);
xx = xs+x;
yy = ys+y;
while(b<=j)
{
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*angle));
ys = (unsigned int)Int_Float(za+ya*angle);
DrawLine(xx, yy, xs+x, ys+y, A_NORMAL);
b+=0.2;
}
}
}


Mon but est de dessiner une sphere (courbes u et v) centree sur l'ecran MAIS en tenant compte :
- de la phase: 0/360°->invisible 90°->moitie gauche visible 180°->entiere 270->moitie droite
- d'un angle definissant la visibilite du pole nord (rotation)

le soucis est que mon code est tres lourd tres lent et ne trace que les latitudes
Comment tracer les meridiens ? et comment faite vous pour tracer plus vite ? ma priorite etant la taille de mon exe final.

Amicalement,
Wolf

DrawLine est une fonction lente, mais le pire c'est l'utilisation de float (et de fonctions les manipulant) : utilise une représentation des nombres avec virgule fixe, et précalcule tes sinus/cosinus. Pour le traçage de lignes, ExtGraph fournit une fonction très rapide, mais peut-être un peu grosse.

salut sasume,
oui je calcul en float car c'est un logiciel d'astronomie (ephemeride et pilotage de telesctope) j'ai don besoin d'une grande precision.
Pour utiliser les virgules fixes, est-ce possible UNIQUEMENT dans une fonction ?

sinon voici le tracage des meridiens :


void DrawSphere(unsigned short x, unsigned short y, unsigned short r, float phase, float angle)
{
float xa = 0.0,
ya = 0.0,
za = 0.0;
unsigned int xs = 0,
xx = 0,
ys = 0,
yy = 0;
float a = 0.0,
b = 0.0,
j = 0.0,
i = 0.0;

for( a=-PI/2.0 ; a<=PI/2.0 ; a+=0.2)
{
if(phase>PI)
{
b=phase-PI; //Deg2Rad(Norm180(Rad2Deg(phase-PI)));
j=PI;
}
else
{
b=0.0;
j=phase;
}
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*(angle)));
ys = (unsigned int)Int_Float(za+ya*(angle));
xx = xs+x;
yy = ys+y;
while(b<=j)
{
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*(angle)))+x;
ys = (unsigned int)Int_Float(za+ya*(angle))+y;
DrawLine(xx, yy, xs, ys, A_NORMAL);
xx = xs;
yy = ys;
b+=0.2;
}
}


if(phase<PI)
{
b=0.0;
i=phase;
}
else
{
b=phase-PI;
i=PI;
}
while( b<=i )
{
if(phase<0)
{
a=phase-PI;
j=PI;
}
else
{
a=-PI/2.0;
j=PI/2.0;
}
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*(angle)));
ys = (unsigned int)Int_Float(za+ya*(angle));
xx = xs+x;
yy = ys+y;
while(a<=j)
{
xa = r*(cos(a)*cos(b));
ya = r*(cos(a)*sin(b));
za = r*sin(a);
xs = ((unsigned int)Int_Float(xa+ya*(angle)))+x;
ys = (unsigned int)Int_Float(za+ya*(angle))+y;
DrawLine(xx, yy, xs, ys, A_NORMAL);
xx = xs;
yy = ys;
a+=0.2;
}
b+=0.2;
}
}


mais c'est encore plus GROS...
ExtGraph est sans doute tres bien, mais je ne crois pas approprie pour mon prog dommage.
je pensais plutot a une petite routine "maison"...
bon j'y retourne
A+

heu

tu ferrait pas mieux d'utiliser autre chose qu'uen TI pourr ce genre de choses ??

pasque bon un ecran en 32x32 avec 2 couleurs :/ c'est pas top top

je te conseillerait plutot un PDA voir un PC (MAC) portable pour ce genre de choses, surtout que les logiciels existent deja sur ce plateformes

wolfgane :
salut sasume,
oui je calcul en float car c'est un logiciel d'astronomie (ephemeride et pilotage de telesctope) j'ai don besoin d'une grande precision.

Tu peux avoir autant de précision que tu veux en virgule fixe ^^ Et honnêtement, pour le code d'affichage, je doute que tu aies besoin de tant de précision que ça : 16 bits pourraient quasiment suffire si tu choisis bien les plages de tes nombres...

Pour utiliser les virgules fixes, est-ce possible UNIQUEMENT dans une fonction ?

 
		xa = r*(cos(a)*cos(b)); 
 		ya = r*(cos(a)*sin(b)); 
 		za = r*sin(a); 
 		xs = ((unsigned int)Int_Float(xa+ya*(angle))); 
 		ys = (unsigned int)Int_Float(za+ya*(angle)); 
 		xx = xs+x; 
 		yy = ys+y; 
   while(b<=j) 
 	 { 
 		xa = r*(cos(a)*cos(b)); 
 		ya = r*(cos(a)*sin(b)); 
		za = r*sin(a); 
 		xs = ((unsigned int)Int_Float(xa+ya*(angle)))+x; 
 		ys = (unsigned int)Int_Float(za+ya*(angle))+y; 
		DrawLine(xx, yy, xs, ys, A_NORMAL); 
 		xx = xs; 
 		yy = ys; 
		b+=0.2; 
   }

Petite remarque, c'est une très mauvaise idée de dupliquer le code comme ça, parce que ton code sera plus pénible à lire, et tu risques de faire des erreurs (que tu ne verras pas forcément si tu ne relis pas attentivement *tous* les bouts de code).

Quelque chose comme :

   xx = -1; 
   b -= 0.2; 
   do 
 	 { 
 		xa = r*(cos(a)*cos(b)); 
 		ya = r*(cos(a)*sin(b)); 
		za = r*sin(a); 
 		xs = ((unsigned int)Int_Float(xa+ya*(angle)))+x; 
 		ys = (unsigned int)Int_Float(za+ya*(angle))+y; 
		if (xx >= 0) 
                    DrawLine(xx, yy, xs, ys, A_NORMAL); 
 		xx = xs; 
 		yy = ys; 
		b+=0.2; 
   } while(b<=j);

serait bien plus lisible et te permettrait de faire des modifications après bien plus facilement... (enfin là la modification que j'ai faite ne marche que si tu supposes que les arguments à DrawLine ne sont pas en dehors de l'écran, ce qui n'est pas forcément vrai; sinon, il n'y a qu'à transformer "xx = -1" en "xx = INT_MIN" et "xx >= 0" en "xx == INT_MIN", ce sera juste un chouilla plus lent et gros)

(idem pour le reste du code, mais j'ai pas envie de le lire )

En reponse a Godzil :

Oui, j'ai meme ce genre de chose sur mon telephone portable
mais j'ai une caltos, avec un port serie, pi voila en plus mon code est portable, donc y'aura ps trop de soucis.

En reponse a Pollus :

oui pour la duplication de code, c ma version bete, je vais faire une fctO car j'utilise cette partie pour d'autre chose aussi.
Je vais regarder comment utiliser la virgule fixe ?!
Je vais 'minspirer de ta routine, mais normalement en travaillant en rad je reste entre -1;1 donc impossible de sortir de l'ecran si je respecte mon echelle.

Amicalement,
Wolf

Une petite optimisation :

/* ====================================================== */
/* = Function : Drawing Sphere = */
/* = Input : X,Y, ray, Phase & angleY, angleX = */
/* = Angles are used for projection formula = */
/* = Output : - = */
/* ====================================================== */
void DrawSphere(unsigned short x, unsigned short y, unsigned short r, float phase, float angleY, float angleX)
{
// real sphere coords
float xa = 0.0,
ya = 0.0,
za = 0.0;
// computation var.
float a = 0.0,
b = 0.0,
j = 0.0;
// counter for latitudes
short int latitude = 0,
longitude = 0,
delta = 0;
short int vertex = 180;
short tab[vertex];
//-----------------------------------------------------------
// computing sphericals points
for( a=-PI/2.0 ; a<=PI/2.0 ; a+=SPHERE_PRECISION,latitude++)
{
if(phase>PI)
{
b=phase-PI;
j=PI;
}
else
{
b=0.0;
j=phase;
}
// compute all the line
while(b<=j)
{
xa = (cos(a)*cos(b));
ya = (cos(a)*sin(b));
za = sin(a);
xa *= r;
ya *= r;
za *= r;
tab[longitude] = (unsigned short)Int_Float(xa*sin(angleX)+ya*-cos(angleX));
tab[longitude] = (unsigned short)Int_Float(za+ya*sin(angleY));
b+=SPHERE_PRECISION;
longitude++;
}
}

delta = (short)ceil((float)(longitude/latitude));
// drawing latitude lines with computed points
for(longitude=0,latitude=1;longitude<(vertex-delta);longitude++,latitude++)
{
if(latitude>=delta)
{
latitude=1;
longitude++;
}
DrawLine(tab[longitude]+x,tab[longitude]+y,tab[longitude+1]+x,tab[longitude+1]+y,A_NORMAL);
}
// drawing longitude lines with latitude's points computed before
for(longitude=0;longitude<(vertex-delta);longitude++)
DrawLine(tab[longitude]+x,tab[longitude]+y,tab[longitude+delta]+x,tab[longitude+delta]+y,A_NORMAL);

}

wolfgane> tu peux utiliser la balise [ pre ] autour de ton code source, de façon à ce qu'il ne soit pas mis en forme (en particulier, que [ 0 ] ne mette pas en blanc)

(pour exemple, edite mon post)

 
tab[0] = 10; 
printf("Hello World !"); 

> ExtGraph est sans doute tres bien, mais je ne crois pas approprie pour mon prog
FMI, pourquoi ? En tout cas, contrairement à presque toutes les autres librairies, ExtGraph n'a pas tout un stub d'init / deinit.

C'est sûr, mais en conséquence elle n'a pas certains features intéressantes de ce libs.

Qu'est ce qui manque ?

disons que quand tu veux gérer des plans avec ExtGraph, tu dois le programmer à la main, à moins d'utiliser un tilemap engine. Alors qu'avec genlib, c'est inclus. Un seul binaire sur la calc, un seul header sur PC, et c'est bon. Pareil pour les fonctions de synchronisation, genlib propose des fonctions et variables très bien foutues pour faire ça tranquillement.

Et ces fonction pour permettre de faire des trucs "tranquillement" ne sont pas faisables sans un "stub d'init/deinit" ?

./10 > gestion du link, affichage de chaines de caractères, zoom, traçage de polygones et d'ellipses.

./12 > Si. Pourquoi ?

"C'est sûr, mais en conséquence elle n'a pas certains features intéressantes de ce libs."

> disons que quand tu veux gérer des plans avec ExtGraph, tu dois le programmer à la main, à moins d'utiliser un tilemap engine.
ExtGraph toute seule, évidemment, car elle n'intègre pas de routines de grayscale. Mais TIGCCLIB et Grib, avec lesquelles elle fonctionne parfaitement, le font !
> Un seul binaire sur la calc,
<troll>Compatibilité on-calc sux, et j'ai des arguments déjà exposés dans d'autres topics - même s'il faut reconnaître un défaut au niveau de la facilité de transfert d'une calculette à une autre, les 92+/V200 sont plus rares !</troll>
> un seul header sur PC,
Certes, mais celui d'ExtGraph (ainsi que la lib) n'est séparé en plusieurs morceaux que parce que pas tout le monde n'a besoin du tilemap engine et de la brute-force (preshifting), qui rendraient le header moitié plus gros et illisible que ce qu'il n'est déjà - ~100 KB !

> Pareil pour les fonctions de synchronisation, genlib propose des fonctions et variables très bien foutues pour faire ça tranquillement.
Idem que plus haut: Grib.

GenLib n'existe qu'en grayscale, alors que beaucoup de programmes utilisant ExtGraph sont en B/W.

./14 > Ah, alors les features sont : pas besoin de passer les adresses des planes où dessiner aux fonction, pas besoin de faire d'appel à GrayOn pour activer les niveaux de gris (puisque gl_init se charge de le faire).
D'ailleurs, je ne vois vraiment pas le problème d'avoir des fonctions d'init/deinit Je suppose que toi même dans tes projets tu dois bien avoir codé une fonction init_system et une fonction quit_system qui se chargent respectivement de mettre en place l'environnement de ton programme et de remettre la TI dans son état initial.
Et puis GrayOn et GrayOff ne sont-ils pas des fonctions d'init/deinit ?

Je vois. Mais perso, je me méfie générallement des lib qui s'occupent de tout, ça les rend moins souples

"D'ailleurs, je ne vois vraiment pas le problème d'avoir des fonctions d'init/deinit"-> Tu parles à qui ? (j'ai jamais dis que j'aimais pas ça moi)

Je m'adressais bien à toi
J'avais l'impression que ça t'embêtait.

>>GenLib n'existe qu'en grayscale, alors que beaucoup de programmes utilisant ExtGraph sont en B/W.
ah... tu es sûr?

Ben, déjà, ça commence par les programmes de TICT: depuis que je maintiens les programmes, j'ai mis ExtGraph dans plusieurs d'entre eux. Il me semble que Civ89, par exemple, utilise ExtGraph.

C'était pour faire remarquer qu'ExtGraph a aussi un mode B/W. "Beaucoup" ne veut en effet pas forcément dire la majorité. Les programmes les plus connus (Ice Hockey 68k et autres de Travis, etc.) sont en grayscale.

Sauf si ça a sauté dans la 1.x (ce dont je doute), Genlib fait effectivement aussi du noir et blanc...

Oui, mais elle n'est pas vraiment conçue pour. Très peu de fonctions permettent de travailler en BW (comparé à ExtGraph qui propose environ toutes ses fonctions en BW/nvg).

Oui bien sûr, mais la fonctionnalité demeure.

C'est ce que je voulais dire. Je ne parlais pas du nombre (évidemment plus important) de progs en gryascale.

Ben, il faut carrément chercher pour voir qu'elle permet en effet de faire du B/W (en fait, je n'avais pas trouvé). Les recherches "BW", "B/W" et "B&W" dans la doc ne retournent presque rien !
Même l'intro ne dit pas immédiatement qu'elle permet de faire du B/W, et encore, c'est assez indirect:
"GENLIB is an asm dynamic (kernel based) graph 4-gray tiles-oriented library for TI-92, TI-92+, Ti-89, V200 and Titanium compatible with C and ASM"
[...]
What are the main features of GENLIB?
[...]
Put fast sprites: more than 13000 sprites (16x16) / second! (B&W).
[...]
The Black&White standard graph functions work with GENLIB.
[...]


Je suppose que Monsieur Julien Sabatier dit en termes peu diplomatiques que je devrais lire la doc et me documenter avant de "critiquer" ?

JS devrait être banni

Puisque sa contribution, que tu m'as décrite, est de son style habituel, il faudrait en effet au moins le kicker du topic...

Pour ce genre de réflexion, toi aussi
Le comportement à adopter face à un post locké, c'est de n'en pas parler... fin de l'affaire.