Ah bah oui, tiens!boddhi a écrit :L'étoile polaire fait partie de la petite ourse...
Merci Boddhi, je me coucherai moins bête ce soir...
Ah bah oui, tiens!boddhi a écrit :L'étoile polaire fait partie de la petite ourse...
Code : Tout sélectionner
Structure Point3D
x.d
y.d
z.d
EndStructure
Structure Star3D
Display.Point3D
Light.i
Position.Point3D
Angle.Point3D
AngleRA.d
AngleDE.d
Magnitude.d
EndStructure
Global NewList Star.Star3D()
Define.d Angle_X, Angle_Y, Angle_Z, Angle_X_Speed, Angle_Y_Speed, Angle_Z_Speed, FPS, Brake
Global Atmosphere.d
Define.d Atmosphere_Min, Atmosphere_Start
Global Visibility.d
Define.d Visibility_Max, Visibility_Start
Define Search_Distance.d, Search_Time.i, Search_Display.i
Define *Search_Star.Star3D, *Search_LastStar.Star3D
Define.i MouseX, MouseY, MouseDX, MouseDY, MouseX_Start, MouseY_Start
Define.i DebugMode
Define.i Display_Center_X, Display_Center_Y, FPS_Counter, FPS_ElapsedTime
Define Display_StarInfo_X, Display_StarInfo_Y, Display_StarInfo_CX, Display_StarInfo_CY, Display_StarInfo_Text.s
Define Display_Zoom_X, Display_Zoom_Y, Display_Zoom_CX, Display_Zoom_CY, Display_Zoom_Text.s
Define Display_Visibility_X, Display_Visibility_Y, Display_Visibility_CX, Display_Visibility_CY, Display_Visibility_Text.s
#Star_Light_Precision = 50
#Star_Image_Size = 7
#Star_Display_Image = (#Star_Image_Size - 1) / 2
Define.i Star_Image, Star_Image_Size, Star_Image_Original, Star_Image_OriginalSize
Define.i Star_Display_MinimumLight, Star_Display_Center_X, Star_Display_Center_Y, Star_Display_MouseX, Star_Display_MouseY, Star_Display_ScreenX, Star_Display_ScreenY
Enumeration
#Pointer
#Pointer3D
#Selection
#Selection3D
#Box
#Box3D
#StarImage
#StarImage_End = #StarImage + #Star_Light_Precision
#StarImage3D
#StarImage3D_End = #StarImage3D + #Star_Light_Precision
EndEnumeration
; Utilisation de PNG
UsePNGImageDecoder()
UsePNGImageEncoder()
; précalcul des cos et sin
#Angle_Resolution = 100
Global Dim Calculation_Cos.d(360 * #Angle_Resolution)
Global Dim Calculation_Sin.d(360 * #Angle_Resolution)
For i = 0 To 360 * #Angle_Resolution
Calculation_Cos(i) = Cos(i * #PI / (180 * #Angle_Resolution))
Calculation_Sin(i) = Sin(i * #PI / (180 * #Angle_Resolution))
Next
Procedure Star_XYZ(*Star.Star3D, Atmosphere.d, Angle_X_Axis.d, Angle_Y_Axis.d, Angle_Z_Axis.d)
; Angle_X_Axis, ay, Angle_Z_Axis : angle de rotation du point sur l'Angle_X_Axise x, y et z, pour avoir un repère 3D décalé par rapport au repère de l'écran
Protected Calcul.Point3D, Sin.d, Cos.d, Angle.i
; Rotation sur l'axe Z
If Angle_Z_Axis
; Cos = Cos(Angle_Z_Axis)
; Sin = Sin(Angle_Z_Axis)
Angle.i = Angle_Z_Axis * #Angle_Resolution * 180 / #PI
Cos = Calculation_Cos(Angle)
Sin = Calculation_Sin(Angle)
Calcul\x = *Star\Position\x * Cos - *Star\Position\y * Sin
Calcul\y = *Star\Position\x * Sin + *Star\Position\y * Cos
Else
Calcul\x = *Star\Position\x
Calcul\y = *Star\Position\y
EndIf
; Debug StrD(Calcul\x) + " , " + StrD(Calcul\y) + " , " + StrD(Origine\z)
; Rotation sur l'axe X
If Angle_X_Axis
; Cos = Cos(Angle_X_Axis)
; Sin = Sin(Angle_X_Axis)
Angle.i = Angle_X_Axis * #Angle_Resolution * 180 / #PI
Cos = Calculation_Cos(Angle)
Sin = Calculation_Sin(Angle)
*Star\Display\y = Calcul\y * Cos - *Star\Position\z * Sin
Calcul\z = Calcul\y * Sin + *Star\Position\z * Cos
Else
*Star\Display\y = Calcul\y
Calcul\z = *Star\Position\z
EndIf
; Debug StrD(Calcul\x) + " , " + StrD(*Star\Display\\y) + " , " + StrD(Calcul\z)
; Rotation sur l'axe Y
If Angle_Y_Axis
; Cos = Cos(Angle_Y_Axis)
; Sin = Sin(Angle_Y_Axis)
Angle.i = Angle_Y_Axis * #Angle_Resolution * 180 / #PI
Cos = Calculation_Cos(Angle)
Sin = Calculation_Sin(Angle)
*Star\Display\z = Calcul\z * Cos - Calcul\x * Sin
*Star\Display\x = Calcul\z * Sin + Calcul\x * Cos
Else
*Star\Display\z = Calcul\z
*Star\Display\x = Calcul\x
EndIf
; Debug StrD(*Star\Display\\x) + " , " + StrD(*Star\Display\\y) + " , " + StrD(*Star\Display\\z)
EndProcedure
Procedure ResizeAlphaImage(Image, Width, Height)
Protected x, x1, x2, Memoire, Image_HDC, Image_Ancienne, Image_Bitmap.BITMAP, Image_BitmapInfo.BITMAPINFO
If IsImage(Image)
; Chargement du HDC
Image_HDC = CreateCompatibleDC_(#Null)
Image_Ancienne = SelectObject_(Image_HDC, ImageID(Image))
; Dimension de l'image
GetObject_(ImageID(Image), SizeOf(BITMAP), @Image_Bitmap)
Image_BitmapInfo\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER)
Image_BitmapInfo\bmiHeader\biWidth = Image_Bitmap\bmWidth
Image_BitmapInfo\bmiHeader\biHeight = Image_Bitmap\bmHeight
Image_BitmapInfo\bmiHeader\biPlanes = 1
Image_BitmapInfo\bmiHeader\biBitCount = 32
; Zone mémoire pour copier l'image
xx = Image_Bitmap\bmWidth * Image_Bitmap\bmHeight - 1
Protected Dim Memoire(xx)
; Copie de l'image en mémoire
GetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Modification de l'image en mémoire
For x = 0 To xx
If Memoire(x) = 0
Memoire(x) = $00FFFFFF
EndIf
Next
; Transfert de la mémoire dans la l'image de base
SetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Fermeture du HDC
SelectObject_(Image_HDC, Image_Ancienne)
DeleteDC_(Image_HDC)
ResizeImage(Image, Width, Height, #PB_Image_Smooth)
EndIf
EndProcedure
Procedure Visibility() ; Modilier la visibilité des étoiles (ciel plus ou moins clair)
Protected Star_Max_Light.d
LastElement(Star())
Star_Max_Light = Abs(Visibility - Star()\Magnitude)
ForEach Star()
Star()\Light = #Star_Light_Precision * (Visibility - Star()\Magnitude) / Star_Max_Light
Next
EndProcedure
Procedure Position() ; Modifier la taille de la carte
ForEach Star()
Star()\Position\x = Star()\Angle\x * Atmosphere
Star()\Position\y = Star()\Angle\y * Atmosphere
Star()\Position\z = Star()\Angle\z * Atmosphere
Next
EndProcedure
;{- Chargement des étoiles
If ReadFile(0, "Etoiles.list")
Repeat
; Lecture des données de l'étoile
AddElement(Star())
Star()\AngleRA = ReadDouble(0)
Star()\AngleDE = ReadDouble(0)
Star()\Magnitude = ReadDouble(0)
; précalcul
Star()\Angle\z = Cos(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Angle\x = Sin(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Angle\y = -Sin(Star()\AngleDE * #PI / 180)
Until Eof(0)
; On trie les étoiles de la moins lumineuse à la plus lumineuse, de cette manière, on affiche les moins lumineuse en premier puis les plus lumineuse.
; Cela évite de dessiner une étoile moins lumineuse sur un étoile plus lumineuse ce qui donne des résultats bizarres, étoiles très lumineuse qui clignote car une étoile peu lumineuse est placé non loin.
SortStructuredList(Star(), #PB_Sort_Descending, OffsetOf(Star3D\Magnitude), #PB_Sort_Double)
CloseFile(0)
EndIf
;}
;{ Test de vitesse - Décommentez cette zone pour lancer le test
; Atmosphere.d = 1000
; Position()
; Angle_X.d = 0.1
; Angle_Y.d = 0.1
; Angle_Z.d = 0.1
;
; Temps1 = ElapsedMilliseconds()
; For nn = 1 To 50
; ForEach Star()
; Star_XYZ(@Star()\Display, Atmosphere, Angle_X, Angle_Y, Angle_Z)
; Next
; Next
; Temps2 = ElapsedMilliseconds()
;
; MessageRequester("Temps", Str(ListSize(Star())) + " étoiles" + Chr(10) + Str((Temps2 - Temps1)/50) + " ms")
; End
;}
;{- Ouverture de l'écran
ExamineDesktops()
Screen_Width = DesktopWidth(0)
Screen_Hight = DesktopHeight(0)
; On ouvre l'openscreen
If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0 Or InitSprite3D() = 0
MessageRequester("Erreur", "Impossible d'initialiser la souris ,le clavier ou l'écran. Vérifiez la présence de DirectX 9 ou supérieur.", 0)
End
EndIf
If OpenScreen(Screen_Width, Screen_Hight, 32, "Ecran", #PB_Screen_WaitSynchronization, DesktopFrequency(0)) = 0
MessageRequester("Erreur", "Impossible d'ouvrir l'écran.", 0)
End
EndIf
;}
;{- Chargement des sprites et polices
LoadSprite(#Pointer, "Pointeur.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Pointer3D, #Pointer)
LoadSprite(#Selection, "Selection.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Selection3D, #Selection)
LoadSprite(#Box, "Bulle.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Box3D, #Box)
LoadFont(0, "Verdana", 9, #PB_Font_HighQuality)
; Création des sprites des étoiles en fonction de la luminosité
; Pour l'étoile avec la luminosité maximum, on prend l'image de l'étoile que l'on réduit à #Star_Image_Size
; Pour une téoile avec 50% de la luminosité maximale, on ajoute une bordure vide autour de l'étoile équivalente à la taille de l'image sur 2, puis on réduit à #Star_Image_Size. L'image de l'étoile sera alors 50% plus petite
; etc ...
Star_Image_Original = LoadImage(#PB_Any, "Etoile.png")
If Star_Image_Original
Star_Image_OriginalSize = ImageWidth(Star_Image_Original)
For i = 1 To #Star_Light_Precision
Star_Image_Size = 105 * #Star_Light_Precision / i
If Star_Image_Size & %1 = 0
Star_Image_Size + 1
EndIf
If Star_Image_Size < Star_Image_OriginalSize * 10
If Star_Display_MinimumLight = 0
Star_Display_MinimumLight = i
EndIf
; Debug "Taille de l'image " + Str(i) + " avant redimensionnant = " + Str(Star_Image_Size)
; Debug "Valeur réelle = " + StrD(105 * #Star_Light_Precision / i, 3)
; Debug "Erreur de précision = " + StrD(((Star_Image_Size - 105 * #Star_Light_Precision / i) / (105 * #Star_Light_Precision / i)) * 100, 3) + "%"
; Debug ""
Star_Image = CreateImage(#PB_Any, Star_Image_Size, Star_Image_Size, 32 | #PB_Image_Transparent)
StartDrawing(ImageOutput(Star_Image))
DrawAlphaImage(ImageID(Star_Image_Original), (Star_Image_Size - Star_Image_OriginalSize) / 2, (Star_Image_Size - Star_Image_OriginalSize) / 2)
StopDrawing()
ResizeAlphaImage(Star_Image, #Star_Image_Size, #Star_Image_Size)
SaveImage(Star_Image, "Temp.png", #PB_ImagePlugin_PNG)
FreeImage(Star_Image)
LoadSprite(#StarImage + i, "Temp.png", #PB_Sprite_AlphaBlending | #PB_Sprite_Texture)
CreateSprite3D(#StarImage3D + i, #StarImage + i)
DeleteFile("Temp.png")
EndIf
Next
FreeImage(Star_Image_Original)
EndIf
;}
;{- Initialisation des valeurs
FirstElement(Star())
Visibility_Max = Star()\Magnitude
Visibility = Visibility_Max / 2
Visibility()
Atmosphere = (Screen_Hight + Screen_Width) / 2
If Screen_Hight < Screen_Width
Atmosphere_Min = Screen_Hight / 2
Else
Atmosphere_Min = Screen_Width / 2
EndIf
Position()
#Speed_Brake = 0.5
Angle_X = 0
Angle_Y = 0
FPS = 1
Display_Center_X = Screen_Width / 2
Display_Center_Y = Screen_Hight / 2
Star_Display_Center_X = Display_Center_X - #Star_Display_Image
Star_Display_Center_Y = Display_Center_Y - #Star_Display_Image
Display_StarInfo_X = Screen_Width - SpriteWidth(#Box) - 32
Display_StarInfo_Y = 32
Display_StarInfo_CX = Display_StarInfo_X + SpriteWidth(#Box) / 2
Display_StarInfo_CY = Display_StarInfo_Y + SpriteHeight(#Box) / 2
Display_Zoom_X = Screen_Width / 2 + 32
Display_Zoom_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Zoom_CX = Display_Zoom_X + SpriteWidth(#Box) / 2
Display_Zoom_CY = Display_Zoom_Y + SpriteHeight(#Box) / 2
Display_Visibility_X = Screen_Width / 2 - SpriteWidth(#Box) - 32
Display_Visibility_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Visibility_CX = Display_Visibility_X + SpriteWidth(#Box) / 2
Display_Visibility_CY = Display_Visibility_Y + SpriteHeight(#Box) / 2
MouseLocate(Display_Center_X, Display_Center_Y)
;}
Repeat
ClearScreen($000000)
; On lit les évènements clavier et souris
ExamineMouse()
ExamineKeyboard()
; Position de la souris
MouseX = MouseX()
MouseY = MouseY()
Star_Display_MouseX = MouseX - #Star_Display_Image
Star_Display_MouseY = MouseY - #Star_Display_Image
MouseDX = MouseDeltaX()
MouseDY = MouseDeltaY()
; Debogage
If KeyboardReleased(#PB_Key_F1)
DebugMode = 1 - DebugMode
EndIf
;{- Déplacement de la carte du ciel à la souris
If MouseButton(#PB_MouseButton_Left)
Angle_Y_Speed = MouseDX / Atmosphere
EndIf
;}
;{- Modification de l'angle d'affichage
Brake = 1 - #Speed_Brake / FPS ; En ralentissant le mouvement de cette manière, on ne tient pas compte du FPS
Angle_X + Angle_X_Speed
If Angle_X > 2 * #PI
Angle_X - 2 * #PI
ElseIf Angle_X < 0
Angle_X + 2 * #PI
EndIf
Angle_X_Speed * Brake
Angle_Y + Angle_Y_Speed
If Angle_Y > 2 * #PI
Angle_Y - 2 * #PI
ElseIf Angle_Y < 0
Angle_Y + 2 * #PI
EndIf
Angle_Y_Speed * Brake
Angle_Z + Angle_Z_Speed
If Angle_Z > 2 * #PI
Angle_Z - 2 * #PI
ElseIf Angle_Z < 0
Angle_Z + 2 * #PI
EndIf
Angle_Z_Speed * Brake
;}
;{- Modification des paramètres
If MouseButton(#PB_MouseButton_Right)
If Display_Parameters = 0
MouseLocate(Display_Center_X, Display_Center_Y)
MouseX_Start = MouseX
MouseY_Start = MouseY
Atmosphere_Start = Atmosphere
Visibility_Start = Visibility
EndIf
Display_Parameters = 1
If MouseDY
If MouseY - Display_Center_Y > 32
Atmosphere = Atmosphere_Start / (1 + (MouseY - Display_Center_Y - 32) * 5 / (Screen_Hight - 64))
ElseIf MouseY - Display_Center_Y < -32
Atmosphere = Atmosphere_Start * (1 + (Display_Center_Y + 32 - MouseY) * 5 / (Screen_Hight - 64))
Else
Atmosphere = Atmosphere_Start
EndIf
If Atmosphere < Atmosphere_Min
Atmosphere = Atmosphere_Min
EndIf
Position()
EndIf
If MouseDX
If MouseX - Display_Center_X > 32
Visibility = Visibility_Start + (MouseX - Display_Center_X - 32) * Visibility_Max / (Screen_Width - 64)
ElseIf MouseX - Display_Center_X < -32
Visibility = Visibility_Start + (MouseX - Display_Center_X + 32) * Visibility_Max / (Screen_Width - 64)
Else
Visibility = Visibility_Start
EndIf
If Visibility < 0
Visibility = 0
ElseIf Visibility > Visibility_Max
Visibility = Visibility_Max
EndIf
Visibility()
EndIf
Else
If Display_Parameters
MouseLocate(MouseX_Start + MouseX - Display_Center_X, MouseY_Start + MouseY - Display_Center_Y)
EndIf
Display_Parameters = 0
EndIf
;}
If Start3D()
;- Affichage des étoiles
; Initialisation de la recherche de l'étoile la plus proche de la souris
Search_Distance = 50
*Search_LastStar = *Search_Star
*Search_Star = 0
Star_Counter = 0
; Pour chaque étoile
ForEach Star()
If Star()\Light > Star_Display_MinimumLight
; Calcul de la position des étoiles
Star_XYZ(@Star()\Display, Atmosphere, Angle_X, Angle_Y, Angle_Z)
; Affichage de l'étoile, si elle est sur l'écran
If Star()\Display\z > 0 And Star()\Display\x >= -Display_Center_X And Star()\Display\x < Display_Center_X - 1 And Star()\Display\y >= -Display_Center_Y And Star()\Display\y < Display_Center_Y - 1
Star_Display_ScreenX = Star_Display_Center_X + Star()\Display\x
Star_Display_ScreenY = Star_Display_Center_Y + Star()\Display\y
Star_Counter + 1
DisplaySprite3D(#StarImage3D + Star()\Light, Star_Display_ScreenX, Star_Display_ScreenY)
; Recherche de l'étoile la plus proche de la souris
Star_Display_ScreenX - Star_Display_MouseX
Star_Display_ScreenY - Star_Display_MouseY
If Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY < Search_Distance
*Search_Star = @Star()
Search_Distance = Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY
EndIf
EndIf
EndIf
Next
; Fin de la recherche de l'étoile la plus proche de la souris
If *Search_Star <> *Search_LastStar
Search_Time = ElapsedMilliseconds()
EndIf
If *Search_Star <> 0 And ElapsedMilliseconds() - Search_Time > 250
Search_Display = 1
Else
Search_Display = 0
EndIf
If Display_Parameters
; Affichage des paramètres
DisplaySprite3D(#Box3D, Display_Zoom_X, Display_Zoom_Y)
DisplaySprite3D(#Box3D, Display_Visibility_X, Display_Visibility_Y)
Else
If Search_Display
; Affichage de la sélection
DisplaySprite3D(#Box3D, Display_StarInfo_X, Display_StarInfo_Y)
DisplaySprite3D(#Selection3D, Display_Center_X + *Search_Star\Display\x - 10, Display_Center_Y + *Search_Star\Display\y - 10)
EndIf
EndIf
; Affichage du pointeur
DisplaySprite3D(#Pointer3D, MouseX, MouseY)
Stop3D()
EndIf
; Texte à afficher
StartDrawing(ScreenOutput())
DrawingMode(#PB_2DDrawing_Transparent)
DrawingFont(FontID(0))
If Display_Parameters ; Affichage des paramètres
Display_Zoom_Text = "Zoom x" + StrD(Atmosphere / Atmosphere_Min, 1)
DrawText(Display_Zoom_CX - TextWidth(Display_Zoom_Text) / 2, Display_Zoom_CY - TextHeight(Display_Zoom_Text) / 2, Display_Zoom_Text, $FFFFFF)
Display_Visibility_Text = "Visibilité = " + StrD(100 * Visibility / Visibility_Max, 0) + "%"
DrawText(Display_Visibility_CX - TextWidth(Display_Visibility_Text) / 2, Display_Visibility_CY - TextHeight(Display_Visibility_Text) / 2, Display_Visibility_Text, $FFFFFF)
ElseIf Search_Display ; Position de l'étoile sélectionnée
Display_StarInfo_Text = StrD(*Search_Star\AngleRA, 3) + " h , " + StrD(*Search_Star\AngleDE, 3) + " °"
DrawText(Display_StarInfo_CX - TextWidth(Display_StarInfo_Text) / 2, Display_StarInfo_CY - TextHeight(Display_StarInfo_Text) / 2, Display_StarInfo_Text, $FFFFFF)
EndIf
If DebugMode
; Debogage
DrawText(0, 0, "FPS : " + Str(FPS))
DrawText(0, 20, "Angle X : " + StrD(Angle_X * 180 / #PI))
DrawText(0, 40, "Angle Y : " + StrD(Angle_Y * 180 / #PI))
DrawText(0, 60, "Angle Z : " + StrD(Angle_Z * 180 / #PI))
DrawText(0, 80, "Etoiles affichées : " + Str(Star_Counter))
If *Search_Star <> 0
DrawText(0, 100, "Etoile angle 1 : " + StrD(*Search_Star\AngleRA))
DrawText(0, 120, "Etoile angle 2 : " + StrD(*Search_Star\AngleDE))
EndIf
EndIf
StopDrawing()
FlipBuffers()
;{ Calcul du FPS
FPS_Counter + 1
If FPS_Counter >= FPS
FPS = FPS_Counter * 1000 / (ElapsedMilliseconds() - FPS_ElapsedTime)
FPS_Counter = 0
FPS_ElapsedTime = ElapsedMilliseconds()
EndIf
;}
If IsScreenActive() = 0 ; Fermer si retour à Windows
End
EndIf
Until KeyboardPushed(#PB_Key_Escape)
Code : Tout sélectionner
EnableExplicit
Structure Point3D
x.d
y.d
z.d
EndStructure
Structure Angle3D
RA.d
DE.d
EndStructure
Structure Star3D
Display.Point3D
Light.i
AngleRA.d
AngleDE.d
Magnitude.d
EndStructure
Global NewList Star.Star3D()
Define i.i
Define.i Screen_Width, Screen_Hight, Screen_Frequency, Screen_Synchronization
Define.d Angle_DE_Speed, Angle_RA_Speed, FPS, Display_Brake
Define.d Atmosphere, Atmosphere_Min, Atmosphere_Start, Atmosphere_Last.d
Define.d Visibility, Visibility_Max, Visibility_Start, Visibility_Min
Define Search_Distance.d, Search_Time.i, Search_Display.i
Define *Search_Star.Star3D, *Search_LastStar.Star3D
Define.i MouseX, MouseY, MouseDX, MouseDY, MouseX_Start, MouseY_Start
#Display_Speed_Brake = 0.5 ; Facteur de réduction de vitesse par seconde
Define.i DebugMode
Define.i Display_Center_X, Display_Center_Y, FPS_Counter, FPS_ElapsedTime
Define.i Display_Screen_XMin, Display_Screen_XMax, Display_Screen_YMin, Display_Screen_YMax
Define.i Display_Parameters
Define Display_StarInfo_X, Display_StarInfo_Y, Display_StarInfo_CX, Display_StarInfo_CY, Display_StarInfo_Text.s
Define Display_Zoom_X, Display_Zoom_Y, Display_Zoom_CX, Display_Zoom_CY, Display_Zoom_Text.s
Define Display_Visibility_X, Display_Visibility_Y, Display_Visibility_CX, Display_Visibility_CY, Display_Visibility_Text.s
#Star_Light_Precision = 60
#Star_Image_Size = 7
#Star_Display_Image = (#Star_Image_Size - 1) / 2
Define.i Star_Image, Star_Image_Size, Star_Image_Original, Star_Image_OriginalSize
Define.i Star_Display_MinimumLight, Star_Display_Center_X, Star_Display_Center_Y, Star_Display_MouseX, Star_Display_MouseY, Star_Display_ScreenX, Star_Display_ScreenY
Define.i Star_Calculation_Counter, Star_Display_Counter
Enumeration
#Pointer
#Pointer3D
#Selection
#Selection3D
#Box
#Box3D
#StarImage
#StarImage_End = #StarImage + #Star_Light_Precision
#StarImage3D
#StarImage3D_End = #StarImage3D + #Star_Light_Precision
EndEnumeration
; Utilisation de PNG
UsePNGImageDecoder()
UsePNGImageEncoder()
; précalcul des cos et sin
#Angle_Resolution = 100
Global Dim Calculation_Cos.d(360 * #Angle_Resolution)
Global Dim Calculation_Sin.d(360 * #Angle_Resolution)
For i = 0 To 360 * #Angle_Resolution
Calculation_Cos(i) = Cos(i * #PI / (180 * #Angle_Resolution))
Calculation_Sin(i) = Sin(i * #PI / (180 * #Angle_Resolution))
Next
Procedure Star_Display_XYZ(*Star.Star3D, Angle_RA.d, Angle_DE.d)
Protected Sin.d, Cos.d, Angle.i, Calcul.Point3D
; Rotation sur l'axe X
If Angle_DE < 0
Angle_DE + 360
EndIf
Angle.i = Angle_DE * #Angle_Resolution
Cos = Calculation_Cos(Angle)
Sin = Calculation_Sin(Angle)
Calcul\z = *Star\Display\y * Sin + *Star\Display\z * Cos
*Star\Display\y = *Star\Display\y * Cos - *Star\Display\z * Sin
; Rotation sur l'axe Y
If Angle_RA < 0
Angle_RA + 360
EndIf
Angle.i = Angle_RA * #Angle_Resolution
Cos = Calculation_Cos(Angle)
Sin = Calculation_Sin(Angle)
*Star\Display\z = Calcul\z * Cos - *Star\Display\x * Sin
*Star\Display\x = Calcul\z * Sin + *Star\Display\x * Cos
EndProcedure
Procedure ResizeAlphaImage(Image, Width, Height)
Protected x, xx, x1, x2, Memoire, Image_HDC, Image_Ancienne, Image_Bitmap.BITMAP, Image_BitmapInfo.BITMAPINFO
If IsImage(Image)
; Chargement du HDC
Image_HDC = CreateCompatibleDC_(#Null)
Image_Ancienne = SelectObject_(Image_HDC, ImageID(Image))
; Dimension de l'image
GetObject_(ImageID(Image), SizeOf(BITMAP), @Image_Bitmap)
Image_BitmapInfo\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER)
Image_BitmapInfo\bmiHeader\biWidth = Image_Bitmap\bmWidth
Image_BitmapInfo\bmiHeader\biHeight = Image_Bitmap\bmHeight
Image_BitmapInfo\bmiHeader\biPlanes = 1
Image_BitmapInfo\bmiHeader\biBitCount = 32
; Zone mémoire pour copier l'image
xx = Image_Bitmap\bmWidth * Image_Bitmap\bmHeight - 1
Protected Dim Memoire(xx)
; Copie de l'image en mémoire
GetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Modification de l'image en mémoire
For x = 0 To xx
If Memoire(x) = 0
Memoire(x) = $00FFFFFF
EndIf
Next
; Transfert de la mémoire dans la l'image de base
SetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Fermeture du HDC
SelectObject_(Image_HDC, Image_Ancienne)
DeleteDC_(Image_HDC)
ResizeImage(Image, Width, Height, #PB_Image_Smooth)
EndIf
EndProcedure
Procedure Visibility(Visibility.d) ; Modilier la visibilité des étoiles (ciel plus ou moins clair)
Protected Star_Max_Light.d
LastElement(Star())
Star_Max_Light = Visibility - Star()\Magnitude
If Star_Max_Light > 0
ForEach Star()
Star()\Light = #Star_Light_Precision * (Visibility - Star()\Magnitude) / Star_Max_Light
Next
Else
ForEach Star()
Star()\Light = 0
Next
EndIf
EndProcedure
Procedure Position(Atmosphere.d, Atmosphere_Last.d) ; Modifier la taille de la carte
ForEach Star()
Star()\Display\x = Star()\Display\x * Atmosphere / Atmosphere_Last
Star()\Display\y = Star()\Display\y * Atmosphere / Atmosphere_Last
Star()\Display\z = Star()\Display\z * Atmosphere / Atmosphere_Last
Next
EndProcedure
;{- Chargement des étoiles
If ReadFile(0, "Etoiles.list")
Repeat
; Lecture des données de l'étoile
AddElement(Star())
Star()\AngleRA = ReadDouble(0)
Star()\AngleDE = ReadDouble(0)
Star()\Magnitude = ReadDouble(0)
; précalcul
Star()\Display\z = Cos(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Display\x = Sin(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Display\y = -Sin(Star()\AngleDE * #PI / 180)
Until Eof(0)
; On trie les étoiles de la moins lumineuse à la plus lumineuse, de cette manière, on affiche les moins lumineuse en premier puis les plus lumineuse.
; Cela évite de dessiner une étoile moins lumineuse sur un étoile plus lumineuse ce qui donne des résultats bizarres, étoiles très lumineuse qui clignote car une étoile peu lumineuse est placé non loin.
SortStructuredList(Star(), #PB_Sort_Descending, OffsetOf(Star3D\Magnitude), #PB_Sort_Double)
CloseFile(0)
EndIf
;}
;{- Préparation
If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0 Or InitSprite3D() = 0
MessageRequester("Erreur", "Impossible d'initialiser la souris ,le clavier ou l'écran. Vérifiez la présence de DirectX 9 ou supérieur.", 0)
End
EndIf
; police
LoadFont(0, "Verdana", 9, #PB_Font_HighQuality)
;}
;{- Initialisation des valeurs
; Dimension de l'écran
ExamineDesktops()
Screen_Width = DesktopWidth(0)
Screen_Hight = DesktopHeight(0)
Screen_Frequency = DesktopFrequency(0)
Screen_Synchronization = #PB_Screen_WaitSynchronization
FPS = 1
; Zoom
Atmosphere = (Screen_Hight + Screen_Width) / 2
If Screen_Hight < Screen_Width
Atmosphere_Min = Screen_Hight / 2
Else
Atmosphere_Min = Screen_Width / 2
EndIf
Position(Atmosphere, 1)
Atmosphere_Last = Atmosphere
; Visibilité
FirstElement(Star())
Visibility_Max = Star()\Magnitude
LastElement(Star())
Visibility_Min = Star()\Magnitude
Visibility = (Visibility_Max - Visibility_Min) * 65 / 100 + Visibility_Min
Visibility(Visibility)
; Angle de départ
ForEach Star()
Star_Display_XYZ(@Star(), 0, 90)
Next
Star_Calculation_Counter = ListSize(Star())
;}
Repeat
;{- Ouverture de l'écran
If OpenScreen(Screen_Width, Screen_Hight, 32, "Ecran", Screen_Synchronization, Screen_Frequency) = 0
MessageRequester("Erreur", "Impossible d'ouvrir l'écran.", 0)
End
EndIf
KeyboardMode(#PB_Keyboard_International)
;}
;{- Chargement des sprites et polices
LoadSprite(#Pointer, "Pointeur.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Pointer3D, #Pointer)
LoadSprite(#Selection, "Selection.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Selection3D, #Selection)
LoadSprite(#Box, "Bulle.png", #PB_Sprite_Texture | #PB_Sprite_AlphaBlending)
CreateSprite3D(#Box3D, #Box)
; Création des sprites des étoiles en fonction de la luminosité
; Pour l'étoile avec la luminosité maximum, on prend l'image de l'étoile que l'on réduit à #Star_Image_Size
; Pour une téoile avec 50% de la luminosité maximale, on ajoute une bordure vide autour de l'étoile équivalente à la taille de l'image sur 2, puis on réduit à #Star_Image_Size. L'image de l'étoile sera alors 50% plus petite
; etc ...
Star_Image_Original = LoadImage(#PB_Any, "Etoile.png")
If Star_Image_Original
Star_Image_OriginalSize = ImageWidth(Star_Image_Original)
For i = 1 To #Star_Light_Precision
Star_Image_Size = 105 * #Star_Light_Precision / i
If Star_Image_Size & %1 = 0
Star_Image_Size + 1
EndIf
If Star_Image_Size < Star_Image_OriginalSize * 10
If Star_Display_MinimumLight = 0
Star_Display_MinimumLight = i
EndIf
; Debug "Taille de l'image " + Str(i) + " avant redimensionnant = " + Str(Star_Image_Size)
; Debug "Valeur réelle = " + StrD(105 * #Star_Light_Precision / i, 3)
; Debug "Erreur de précision = " + StrD(((Star_Image_Size - 105 * #Star_Light_Precision / i) / (105 * #Star_Light_Precision / i)) * 100, 3) + "%"
; Debug ""
Star_Image = CreateImage(#PB_Any, Star_Image_Size, Star_Image_Size, 32 | #PB_Image_Transparent)
StartDrawing(ImageOutput(Star_Image))
DrawAlphaImage(ImageID(Star_Image_Original), (Star_Image_Size - Star_Image_OriginalSize) / 2, (Star_Image_Size - Star_Image_OriginalSize) / 2)
StopDrawing()
ResizeAlphaImage(Star_Image, #Star_Image_Size, #Star_Image_Size)
SaveImage(Star_Image, "Temp.png", #PB_ImagePlugin_PNG)
FreeImage(Star_Image)
LoadSprite(#StarImage + i, "Temp.png", #PB_Sprite_AlphaBlending | #PB_Sprite_Texture)
CreateSprite3D(#StarImage3D + i, #StarImage + i)
DeleteFile("Temp.png")
EndIf
Next
FreeImage(Star_Image_Original)
EndIf
;}
;{- Initialisation de l'affichage
Display_Center_X = Screen_Width / 2
Display_Center_Y = Screen_Hight / 2
Display_Screen_XMin = -Display_Center_X
Display_Screen_XMax = Display_Center_X - 1
Display_Screen_YMin = -Display_Center_Y
Display_Screen_YMax = Display_Center_Y - 1
Star_Display_Center_X = Display_Center_X - #Star_Display_Image
Star_Display_Center_Y = Display_Center_Y - #Star_Display_Image
Display_StarInfo_X = Screen_Width - SpriteWidth(#Box) - 32
Display_StarInfo_Y = 32
Display_StarInfo_CX = Display_StarInfo_X + SpriteWidth(#Box) / 2
Display_StarInfo_CY = Display_StarInfo_Y + SpriteHeight(#Box) / 2
Display_Zoom_X = Screen_Width / 2 + 32
Display_Zoom_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Zoom_CX = Display_Zoom_X + SpriteWidth(#Box) / 2
Display_Zoom_CY = Display_Zoom_Y + SpriteHeight(#Box) / 2
Display_Visibility_X = Screen_Width / 2 - SpriteWidth(#Box) - 32
Display_Visibility_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Visibility_CX = Display_Visibility_X + SpriteWidth(#Box) / 2
Display_Visibility_CY = Display_Visibility_Y + SpriteHeight(#Box) / 2
MouseLocate(Display_Center_X, Display_Center_Y)
;}
Repeat
ClearScreen($000000)
; On lit les évènements clavier et souris
ExamineMouse()
ExamineKeyboard()
; Position de la souris
MouseX = MouseX()
MouseY = MouseY()
Star_Display_MouseX = MouseX - #Star_Display_Image
Star_Display_MouseY = MouseY - #Star_Display_Image
MouseDX = MouseDeltaX()
MouseDY = MouseDeltaY()
; Debogage
If KeyboardReleased(#PB_Key_F1) ; Affichage du débogage
DebugMode = 1 - DebugMode
EndIf
If DebugMode And KeyboardReleased(#PB_Key_F2) ; Changment du mode de synchronisation
Break
EndIf
;{- Déplacement de la carte du ciel à la souris
If MouseButton(#PB_MouseButton_Left)
Angle_DE_Speed = ASin(MouseDY / Atmosphere) * 180 / #PI
Angle_RA_Speed = ASin(MouseDX / Atmosphere) * -180 / #PI
EndIf
If KeyboardPushed(#PB_Key_Up)
Angle_DE_Speed = -1
EndIf
If KeyboardPushed(#PB_Key_Down)
Angle_DE_Speed = 1
EndIf
If KeyboardPushed(#PB_Key_Right)
Angle_RA_Speed = -1
EndIf
If KeyboardPushed(#PB_Key_Left)
Angle_RA_Speed = 1
EndIf
;}
;{- Modification des paramètres
If MouseButton(#PB_MouseButton_Right)
If Display_Parameters = 0
MouseLocate(Display_Center_X, Display_Center_Y)
MouseX_Start = MouseX
MouseY_Start = MouseY
Atmosphere_Start = Atmosphere
Visibility_Start = Visibility
EndIf
Display_Parameters = 1
If MouseDY
If MouseY - Display_Center_Y > 32
Atmosphere = Atmosphere_Start / (1 + (MouseY - Display_Center_Y - 32) * 5 / (Screen_Hight - 64))
ElseIf MouseY - Display_Center_Y < -32
Atmosphere = Atmosphere_Start * (1 + (Display_Center_Y + 32 - MouseY) * 5 / (Screen_Hight - 64))
Else
Atmosphere = Atmosphere_Start
EndIf
If Atmosphere < Atmosphere_Min
Atmosphere = Atmosphere_Min
EndIf
Position(Atmosphere, Atmosphere_Last)
Atmosphere_Last = Atmosphere
EndIf
If MouseDX
If MouseX - Display_Center_X > 32
Visibility = Visibility_Start + (MouseX - Display_Center_X - 32) * (Visibility_Max - Visibility_Min) / (Screen_Width - 64)
ElseIf MouseX - Display_Center_X < -32
Visibility = Visibility_Start + (MouseX - Display_Center_X + 32) * (Visibility_Max - Visibility_Min) / (Screen_Width - 64)
Else
Visibility = Visibility_Start
EndIf
If Visibility < Visibility_Min
Visibility = Visibility_Min
ElseIf Visibility > Visibility_Max
Visibility = Visibility_Max
EndIf
Visibility(Visibility)
EndIf
Else
If Display_Parameters
MouseLocate(MouseX_Start + MouseX - Display_Center_X, MouseY_Start + MouseY - Display_Center_Y)
EndIf
Display_Parameters = 0
EndIf
;}
If Start3D()
;- Affichage des étoiles
; Initialisation de la recherche de l'étoile la plus proche de la souris
Search_Distance = 7 * 7
*Search_LastStar = *Search_Star
*Search_Star = 0
Star_Display_Counter = 0
; Pour chaque étoile
ForEach Star()
Star_Display_XYZ(@Star()\Display, Angle_RA_Speed, Angle_DE_Speed)
; Affichage de l'étoile, si elle est sur l'écran et visible
If Star()\Light > Star_Display_MinimumLight And Star()\Display\z < 0 And Star()\Display\x >= Display_Screen_XMin And Star()\Display\x < Display_Screen_XMax And Star()\Display\y >= Display_Screen_YMin And Star()\Display\y < Display_Screen_YMax
Star_Display_ScreenX = Star_Display_Center_X + Star()\Display\x
Star_Display_ScreenY = Star_Display_Center_Y + Star()\Display\y
Star_Display_Counter + 1
DisplaySprite3D(#StarImage3D + Star()\Light, Star_Display_ScreenX, Star_Display_ScreenY)
; Recherche de l'étoile la plus proche de la souris
Star_Display_ScreenX - Star_Display_MouseX
Star_Display_ScreenY - Star_Display_MouseY
If Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY < Search_Distance
*Search_Star = @Star()
Search_Distance = Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY
EndIf
EndIf
Next
; Fin de la recherche de l'étoile la plus proche de la souris
If *Search_Star <> *Search_LastStar
Search_Time = ElapsedMilliseconds()
EndIf
If *Search_Star <> 0 And ElapsedMilliseconds() - Search_Time > 250
Search_Display = 1
Else
Search_Display = 0
EndIf
If Display_Parameters
; Affichage des paramètres
DisplaySprite3D(#Box3D, Display_Zoom_X, Display_Zoom_Y)
DisplaySprite3D(#Box3D, Display_Visibility_X, Display_Visibility_Y)
Else
If Search_Display
; Affichage de la sélection
DisplaySprite3D(#Box3D, Display_StarInfo_X, Display_StarInfo_Y)
DisplaySprite3D(#Selection3D, Display_Center_X + *Search_Star\Display\x - 10, Display_Center_Y + *Search_Star\Display\y - 10)
EndIf
EndIf
; Affichage du pointeur
DisplaySprite3D(#Pointer3D, MouseX, MouseY)
Stop3D()
EndIf
; Texte à afficher
StartDrawing(ScreenOutput())
DrawingMode(#PB_2DDrawing_Transparent)
DrawingFont(FontID(0))
If Display_Parameters ; Affichage des paramètres
Display_Zoom_Text = "Zoom x" + StrD(Atmosphere / Atmosphere_Min, 1)
DrawText(Display_Zoom_CX - TextWidth(Display_Zoom_Text) / 2, Display_Zoom_CY - TextHeight(Display_Zoom_Text) / 2, Display_Zoom_Text, $FFFFFF)
Display_Visibility_Text = "Visibilité = " + StrD(100 * (Visibility - Visibility_Min) / (Visibility_Max - Visibility_Min), 0) + "%"
DrawText(Display_Visibility_CX - TextWidth(Display_Visibility_Text) / 2, Display_Visibility_CY - TextHeight(Display_Visibility_Text) / 2, Display_Visibility_Text, $FFFFFF)
ElseIf Search_Display ; Position de l'étoile sélectionnée
Display_StarInfo_Text = StrD(*Search_Star\AngleRA, 3) + " h , " + StrD(*Search_Star\AngleDE, 3) + " °"
DrawText(Display_StarInfo_CX - TextWidth(Display_StarInfo_Text) / 2, Display_StarInfo_CY - TextHeight(Display_StarInfo_Text) / 2, Display_StarInfo_Text, $FFFFFF)
EndIf
If DebugMode
; Debogage
DrawText(0, 0, "FPS : " + StrD(FPS, 1) + " ; " + StrD(100 * FPS / Screen_Frequency, 1) + "%")
DrawText(0, 20, "Synchronisation : " + Str(Screen_Synchronization) + " (F2 pour changer)")
DrawText(0, 40, "Etoiles calculées : " + Str(Star_Calculation_Counter))
DrawText(0, 60, "Etoiles affichées : " + Str(Star_Display_Counter))
If *Search_Star <> 0
DrawText(0, 80, "Etoile angle RA : " + StrD(*Search_Star\AngleRA))
DrawText(0, 100, "Etoile angle DE : " + StrD(*Search_Star\AngleDE))
EndIf
EndIf
StopDrawing()
;{- Modification de la vitesse de rotation de l'affichage
Angle_DE_Speed * Display_Brake ; Le ralentissement est calculé en même temps que le FPS car il dépend du FPS (le ralentissmeent est le même qlque soit le FPS
Angle_RA_Speed * Display_Brake
;}
FlipBuffers()
;{ Calcul du FPS
FPS_Counter + 1
If FPS_Counter >= FPS
FPS = FPS_Counter * 1000 / (ElapsedMilliseconds() - FPS_ElapsedTime)
FPS_Counter = 0
FPS_ElapsedTime = ElapsedMilliseconds()
If FPS <= 0
FPS = 1
EndIf
Display_Brake = Pow(#Display_Speed_Brake, (1 / FPS)) ; En ralentissant le mouvement de cette manière, on ne tient pas compte du FPS
EndIf
;}
If KeyboardPushed(#PB_Key_Escape) Or IsScreenActive() = 0 ; Fermer si Echap ou retour à Windows
End
EndIf
ForEver
; On change la synchronisation de l'écran
CloseScreen()
Select Screen_Synchronization
Case #PB_Screen_NoSynchronization
Screen_Synchronization = #PB_Screen_WaitSynchronization
Case #PB_Screen_WaitSynchronization
Screen_Synchronization = #PB_Screen_SmartSynchronization
Case #PB_Screen_SmartSynchronization
Screen_Synchronization = #PB_Screen_NoSynchronization
EndSelect
ForEver
??Le Soldat Inconnu a écrit :Code mis à jour
Copie du programme APRES mise à jour
Code : Tout sélectionner
EnableExplicit
Structure Repere3D
ix.d
iy.d
iz.d
jx.d
jy.d
jz.d
kx.d
ky.d
kz.d
EndStructure
Global Repere.Repere3D
Structure Point3D
x.d
y.d
z.d
EndStructure
Structure Angle3D
RA.d
DE.d
EndStructure
Structure Star3D
Display.Point3D
Position.Point3D
Light.i
AngleRA.d
AngleDE.d
Magnitude.d
Description.s
EndStructure
Global NewList Star.Star3D()
Define i.i
Define.i Screen_Width, Screen_Hight, Screen_Frequency, Screen_Synchronization
Define.d Angle_DE_Speed, Angle_RA_Speed, FPS, Display_Brake
Define.d Atmosphere, Atmosphere_Min, Atmosphere_Start, Atmosphere_Last.d
Define.d Visibility, Visibility_Max, Visibility_Start, Visibility_Min
Define Search_Distance.d, Search_Time.i, Search_Display.i
Define *Search_Star.Star3D, *Search_LastStar.Star3D
Define.i MouseX, MouseY, MouseDX, MouseDY, MouseX_Start, MouseY_Start
#Display_Speed_Brake = 0.5 ; Facteur de réduction de vitesse par seconde
Define.i DebugMode
Define.i Display_Center_X, Display_Center_Y, FPS_Counter, FPS_ElapsedTime
Define.i Display_Screen_XMin, Display_Screen_XMax, Display_Screen_YMin, Display_Screen_YMax
Define.i Display_Parameters
Define Display_StarInfo_X, Display_StarInfo_Y, Display_StarInfo_CX, Display_StarInfo_CY
Define Display_Zoom_X, Display_Zoom_Y, Display_Zoom_CX, Display_Zoom_CY, Display_Zoom_Text.s
Define Display_Visibility_X, Display_Visibility_Y, Display_Visibility_CX, Display_Visibility_CY, Display_Visibility_Text.s
#Star_Light_Precision = 50
#Star_Image_Size = 7
#Star_Display_Image = (#Star_Image_Size - 1) / 2
Define.i Star_Image, Star_Image_Size, Star_Image_Original, Star_Image_OriginalSize
Define.i Star_Display_MinimumLight, Star_Display_Center_X, Star_Display_Center_Y, Star_Display_MouseX, Star_Display_MouseY, Star_Display_ScreenX, Star_Display_ScreenY
Define.i Star_Calculation_Counter, Star_Display_Counter
Enumeration
#Pointer
#Pointer3D
#Selection
#Selection3D
#Box
#Box3D
#StarImage
#StarImage_End = #StarImage + #Star_Light_Precision
#StarImage3D
#StarImage3D_End = #StarImage3D + #Star_Light_Precision
EndEnumeration
; Utilisation de PNG
UsePNGImageDecoder()
UsePNGImageEncoder()
#Optimisation = 1
CompilerIf #Optimisation
#Angle_Resolution = 200
Global Dim PreCalcul_Cos.d(360 * #Angle_Resolution * 2)
Global Dim PreCalcul_Sin.d(360 * #Angle_Resolution * 2)
For i = -360 * #Angle_Resolution To 360 * #Angle_Resolution
PreCalcul_Cos(i + 360 * #Angle_Resolution) = Cos(i * #PI / (180 * #Angle_Resolution))
PreCalcul_Sin(i + 360 * #Angle_Resolution) = Sin(i * #PI / (180 * #Angle_Resolution))
Next
CompilerEndIf
Procedure Rotate_Reset(*Repere.Repere3D)
Repere\ix = 1
Repere\iy = 0
Repere\iz = 0
Repere\jx = 0
Repere\jy = 1
Repere\jz = 0
Repere\kx = 0
Repere\ky = 0
Repere\kz = 1
EndProcedure
Macro Rotate_Axis_Angle()
CompilerIf #Optimisation
Protected a.i
a = Angle * #Angle_Resolution * 180 / #PI + 360 * #Angle_Resolution
Cos = PreCalcul_Cos(a)
Sin = PreCalcul_Sin(a)
CompilerElse
Cos = Cos(Angle)
Sin = Sin(Angle)
CompilerEndIf
EndMacro
Macro Rotate_Axis_Calculation(Axe1, Axe2, Cos, Sin)
x = Axe1
Axe1 = x * Cos - Axe2 * Sin
Axe2 = Axe2 * Cos + x * Sin
EndMacro
Procedure Rotate_Axis_X(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\iy, *Repere\iz, Cos, Sin)
Rotate_Axis_Calculation(*Repere\jy, *Repere\jz, Cos, Sin)
Rotate_Axis_Calculation(*Repere\ky, *Repere\kz, Cos, Sin)
EndProcedure
Procedure Rotate_Axis_Y(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\iz, *Repere\ix, Cos, Sin)
Rotate_Axis_Calculation(*Repere\jz, *Repere\jx, Cos, Sin)
Rotate_Axis_Calculation(*Repere\kz, *Repere\kx, Cos, Sin)
EndProcedure
Procedure Rotate_Axis_Z(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\ix, *Repere\iy, Cos, Sin)
Rotate_Axis_Calculation(*Repere\jx, *Repere\jy, Cos, Sin)
Rotate_Axis_Calculation(*Repere\kx, *Repere\ky, Cos, Sin)
EndProcedure
Procedure Rotate_Axis_I(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\kx, *Repere\jx, Cos, Sin)
Rotate_Axis_Calculation(*Repere\ky, *Repere\jy, Cos, Sin)
Rotate_Axis_Calculation(*Repere\kz, *Repere\jz, Cos, Sin)
EndProcedure
Procedure Rotate_Axis_J(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\ix, *Repere\kx, Cos, Sin)
Rotate_Axis_Calculation(*Repere\iy, *Repere\ky, Cos, Sin)
Rotate_Axis_Calculation(*Repere\iz, *Repere\kz, Cos, Sin)
EndProcedure
Procedure Rotate_Axis_K(*Repere.Repere3D, Angle.d)
Protected Cos.d, Sin.d, x.d
Rotate_Axis_Angle()
Rotate_Axis_Calculation(*Repere\jx, *Repere\ix, Cos, Sin)
Rotate_Axis_Calculation(*Repere\jy, *Repere\iy, Cos, Sin)
Rotate_Axis_Calculation(*Repere\jz, *Repere\iz, Cos, Sin)
EndProcedure
Procedure XYZ(*Repere.Repere3D, *PointIJK.Point3D, *PointXYZ.Point3D)
*PointXYZ\x = *PointIJK\x * *Repere\ix + *PointIJK\y * *Repere\jx + *PointIJK\z * *Repere\kx
*PointXYZ\y = *PointIJK\x * *Repere\iy + *PointIJK\y * *Repere\jy + *PointIJK\z * *Repere\ky
*PointXYZ\z = *PointIJK\x * *Repere\iz + *PointIJK\y * *Repere\jz + *PointIJK\z * *Repere\kz
EndProcedure
Procedure ResizeAlphaImage(Image, Width, Height)
Protected x, xx, x1, x2, Memoire, Image_HDC, Image_Ancienne, Image_Bitmap.BITMAP, Image_BitmapInfo.BITMAPINFO
If IsImage(Image)
; Chargement du HDC
Image_HDC = CreateCompatibleDC_(#Null)
Image_Ancienne = SelectObject_(Image_HDC, ImageID(Image))
; Dimension de l'image
GetObject_(ImageID(Image), SizeOf(BITMAP), @Image_Bitmap)
Image_BitmapInfo\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER)
Image_BitmapInfo\bmiHeader\biWidth = Image_Bitmap\bmWidth
Image_BitmapInfo\bmiHeader\biHeight = Image_Bitmap\bmHeight
Image_BitmapInfo\bmiHeader\biPlanes = 1
Image_BitmapInfo\bmiHeader\biBitCount = 32
; Zone mémoire pour copier l'image
xx = Image_Bitmap\bmWidth * Image_Bitmap\bmHeight - 1
Protected Dim Memoire(xx)
; Copie de l'image en mémoire
GetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Modification de l'image en mémoire
For x = 0 To xx
If Memoire(x) = 0
Memoire(x) = $00FFFFFF
EndIf
Next
; Transfert de la mémoire dans la l'image de base
SetDIBits_(Image_HDC, ImageID(Image), 0, Image_Bitmap\bmHeight, @Memoire(), @Image_BitmapInfo, #DIB_RGB_COLORS)
; Fermeture du HDC
SelectObject_(Image_HDC, Image_Ancienne)
DeleteDC_(Image_HDC)
ResizeImage(Image, Width, Height, #PB_Image_Smooth)
EndIf
EndProcedure
Procedure Visibility(Visibility.d) ; Modilier la visibilité des étoiles (ciel plus ou moins clair)
Protected Star_Max_Light.d
LastElement(Star())
Star_Max_Light = Visibility - Star()\Magnitude
If Star_Max_Light > 0
ForEach Star()
Star()\Light = #Star_Light_Precision * (Visibility - Star()\Magnitude) / Star_Max_Light
Next
Else
ForEach Star()
Star()\Light = 0
Next
EndIf
EndProcedure
Procedure Position(Atmosphere.d, Atmosphere_Last.d) ; Modifier la taille de la carte
ForEach Star()
Star()\Display\x = Star()\Display\x * Atmosphere / Atmosphere_Last
Star()\Display\y = Star()\Display\y * Atmosphere / Atmosphere_Last
Star()\Display\z = Star()\Display\z * Atmosphere / Atmosphere_Last
Next
EndProcedure
Procedure MySky() ; Afficher le ciel visible ce soir
Rotate_Axis_X(@Repere, #PI / 2)
; Le 21 mars à 0h, angle de 0 radian
Rotate_Axis_Z(@Repere, -#PI / 2)
EndProcedure
;{- Chargement des étoiles
If ReadFile(0, "Etoiles.list")
Repeat
; Lecture des données de l'étoile
AddElement(Star())
Star()\AngleRA = ReadDouble(0)
Star()\AngleDE = ReadDouble(0)
Star()\Magnitude = ReadDouble(0)
; précalcul
Star()\Position\z = Cos(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Position\x = Sin(Star()\AngleRA * #PI / 180) * Cos(Star()\AngleDE * #PI / 180)
Star()\Position\y = -Sin(Star()\AngleDE * #PI / 180)
Star()\Description = StrD(Star()\AngleRA, 3) + " h , " + StrD(Star()\AngleDE, 3) + " °"
Until Eof(0)
; On trie les étoiles de la moins lumineuse à la plus lumineuse, de cette manière, on affiche les moins lumineuse en premier puis les plus lumineuse.
; Cela évite de dessiner une étoile moins lumineuse sur un étoile plus lumineuse ce qui donne des résultats bizarres, étoiles très lumineuse qui clignote car une étoile peu lumineuse est placé non loin.
SortStructuredList(Star(), #PB_Sort_Descending, OffsetOf(Star3D\Magnitude), #PB_Double)
CloseFile(0)
EndIf
;}
;{- Préparation
If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0; Or InitSprite3D() = 0
MessageRequester("Erreur", "Impossible d'initialiser la souris ,le clavier ou l'écran. Vérifiez la présence de DirectX 9 ou supérieur.", 0)
End
EndIf
; police
LoadFont(0, "Verdana", 9, #PB_Font_HighQuality)
;}
;{- Initialisation des valeurs
; Dimension de l'écran
ExamineDesktops()
Screen_Width = DesktopWidth(0)
Screen_Hight = DesktopHeight(0)
Screen_Frequency = DesktopFrequency(0)
Screen_Synchronization = #PB_Screen_WaitSynchronization
FPS = 1
; Zoom
Atmosphere = (Screen_Hight + Screen_Width) / 2
If Screen_Hight < Screen_Width
Atmosphere_Min = Screen_Hight / 2
Else
Atmosphere_Min = Screen_Width / 2
EndIf
Position(Atmosphere, 1)
Atmosphere_Last = Atmosphere
; Visibilité
FirstElement(Star())
Visibility_Max = Star()\Magnitude
LastElement(Star())
Visibility_Min = Star()\Magnitude
Visibility = (Visibility_Max - Visibility_Min) * 65 / 100 + Visibility_Min
Visibility(Visibility)
; Repère
Rotate_Reset(@Repere)
; Angle de départ
MySky()
Star_Calculation_Counter = ListSize(Star())
;}
Repeat
;{- Ouverture de l'écran
If OpenScreen(Screen_Width, Screen_Hight, 32, "Ecran", Screen_Synchronization, Screen_Frequency) = 0
MessageRequester("Erreur", "Impossible d'ouvrir l'écran.", 0)
End
EndIf
KeyboardMode(#PB_Keyboard_International)
;}
;{- Chargement des sprites et polices
LoadSprite(#Pointer, "Pointeur.png", #PB_Sprite_AlphaBlending)
LoadSprite(#Pointer3D, "Pointeur.png", #PB_Sprite_AlphaBlending)
; CreateSprite(#Pointer3D, #Pointer)
LoadSprite(#Selection, "Selection.png", #PB_Sprite_AlphaBlending)
LoadSprite(#Selection3D, "Selection.png", #PB_Sprite_AlphaBlending)
; CreateSprite3D(#Selection3D, #Selection)
LoadSprite(#Box, "Bulle.png", #PB_Sprite_AlphaBlending)
LoadSprite(#Box3d, "Bulle.png", #PB_Sprite_AlphaBlending)
; CreateSprite3D(#Box3D, #Box)
; Création des sprites des étoiles en fonction de la luminosité
; Pour l'étoile avec la luminosité maximum, on prend l'image de l'étoile que l'on réduit à #Star_Image_Size
; Pour une étoile avec 50% de la luminosité maximale, on ajoute une bordure vide autour de l'étoile équivalente à la taille de l'image sur 2, puis on réduit à #Star_Image_Size. L'image de l'étoile sera alors 50% plus petite
; etc ...
Star_Image_Original = LoadImage(#PB_Any, "Etoile.png")
If Star_Image_Original
Star_Image_OriginalSize = ImageWidth(Star_Image_Original)
For i = 1 To #Star_Light_Precision
Star_Image_Size = 105 * #Star_Light_Precision / i
If Star_Image_Size & %1 = 0
Star_Image_Size + 1
EndIf
If Star_Image_Size < Star_Image_OriginalSize * 10
If Star_Display_MinimumLight = 0
Star_Display_MinimumLight = i
EndIf
; Debug "Taille de l'image " + Str(i) + " avant redimensionnant = " + Str(Star_Image_Size)
; Debug "Valeur réelle = " + StrD(105 * #Star_Light_Precision / i, 3)
; Debug "Erreur de précision = " + StrD(((Star_Image_Size - 105 * #Star_Light_Precision / i) / (105 * #Star_Light_Precision / i)) * 100, 3) + "%"
; Debug ""
Star_Image = CreateImage(#PB_Any, Star_Image_Size, Star_Image_Size, 32, #PB_Image_Transparent)
StartDrawing(ImageOutput(Star_Image))
DrawAlphaImage(ImageID(Star_Image_Original),(Star_Image_Size - Star_Image_OriginalSize) / 2,(Star_Image_Size - Star_Image_OriginalSize) / 2)
StopDrawing()
ResizeAlphaImage(Star_Image, #Star_Image_Size, #Star_Image_Size)
SaveImage(Star_Image, "Temp.png", #PB_ImagePlugin_PNG)
FreeImage(Star_Image)
LoadSprite(#StarImage3D + i, "Temp.png", #PB_Sprite_AlphaBlending)
; CreateSprite3D(#StarImage3D + i, #StarImage + i)
DeleteFile("Temp.png")
EndIf
Next
FreeImage(Star_Image_Original)
EndIf
;}
;{- Initialisation de l'affichage
Display_Center_X = Screen_Width / 2
Display_Center_Y = Screen_Hight / 2
Display_Screen_XMin = -Display_Center_X
Display_Screen_XMax = Display_Center_X - 1
Display_Screen_YMin = -Display_Center_Y
Display_Screen_YMax = Display_Center_Y - 1
Star_Display_Center_X = Display_Center_X - #Star_Display_Image
Star_Display_Center_Y = Display_Center_Y - #Star_Display_Image
Display_StarInfo_X = Screen_Width - SpriteWidth(#Box) - 32
Display_StarInfo_Y = 32
Display_StarInfo_CX = Display_StarInfo_X + SpriteWidth(#Box) / 2
Display_StarInfo_CY = Display_StarInfo_Y + SpriteHeight(#Box) / 2
Display_Zoom_X = Screen_Width / 2 + 32
Display_Zoom_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Zoom_CX = Display_Zoom_X + SpriteWidth(#Box) / 2
Display_Zoom_CY = Display_Zoom_Y + SpriteHeight(#Box) / 2
Display_Visibility_X = Screen_Width / 2 - SpriteWidth(#Box) - 32
Display_Visibility_Y = Screen_Hight / 2 - SpriteHeight(#Box) / 2
Display_Visibility_CX = Display_Visibility_X + SpriteWidth(#Box) / 2
Display_Visibility_CY = Display_Visibility_Y + SpriteHeight(#Box) / 2
MouseLocate(Display_Center_X, Display_Center_Y)
;}
Repeat
ClearScreen($000000)
; On lit les évènements clavier et souris
ExamineMouse()
ExamineKeyboard()
; Position de la souris
MouseX = MouseX()
MouseY = MouseY()
Star_Display_MouseX = MouseX - #Star_Display_Image
Star_Display_MouseY = MouseY - #Star_Display_Image
MouseDX = MouseDeltaX()
MouseDY = MouseDeltaY()
; Debogage
If KeyboardReleased(#PB_Key_F1) ; Affichage du débogage
DebugMode = 1 - DebugMode
EndIf
If DebugMode And KeyboardReleased(#PB_Key_F2) ; Changment du mode de synchronisation
Break
EndIf
;{- Déplacement de la carte du ciel à la souris ou au clavier
If MouseButton(#PB_MouseButton_Left)
Angle_DE_Speed = ASin(MouseDY / Atmosphere)
Angle_RA_Speed = -ASin(MouseDX / Atmosphere)
EndIf
If MouseButton(#PB_MouseButton_Middle)
MySky()
EndIf
If KeyboardPushed(#PB_Key_Up)
Angle_DE_Speed = -#PI / 180
EndIf
If KeyboardPushed(#PB_Key_Down)
Angle_DE_Speed = #PI / 180
EndIf
If KeyboardPushed(#PB_Key_Right)
Angle_RA_Speed = -#PI / 180
EndIf
If KeyboardPushed(#PB_Key_Left)
Angle_RA_Speed = #PI / 180
EndIf
If KeyboardPushed(#PB_Key_Space)
Rotate_Axis_X(@Repere, #PI / 2)
EndIf
;}
;{- Modification des paramètres
If MouseButton(#PB_MouseButton_Right)
If Display_Parameters = 0
MouseLocate(Display_Center_X, Display_Center_Y)
MouseX_Start = MouseX
MouseY_Start = MouseY
Atmosphere_Start = Atmosphere
Visibility_Start = Visibility
EndIf
Display_Parameters = 1
If MouseDY
If MouseY - Display_Center_Y > 32
Atmosphere = Atmosphere_Start / (1 + (MouseY - Display_Center_Y - 32) * 5 / (Screen_Hight - 64))
ElseIf MouseY - Display_Center_Y < -32
Atmosphere = Atmosphere_Start * (1 + (Display_Center_Y + 32 - MouseY) * 5 / (Screen_Hight - 64))
Else
Atmosphere = Atmosphere_Start
EndIf
If Atmosphere < Atmosphere_Min
Atmosphere = Atmosphere_Min
EndIf
Position(Atmosphere, Atmosphere_Last)
Atmosphere_Last = Atmosphere
EndIf
If MouseDX
If MouseX - Display_Center_X > 32
Visibility = Visibility_Start + (MouseX - Display_Center_X - 32) * (Visibility_Max - Visibility_Min) / (Screen_Width - 64)
ElseIf MouseX - Display_Center_X < -32
Visibility = Visibility_Start + (MouseX - Display_Center_X + 32) * (Visibility_Max - Visibility_Min) / (Screen_Width - 64)
Else
Visibility = Visibility_Start
EndIf
If Visibility < Visibility_Min
Visibility = Visibility_Min
ElseIf Visibility > Visibility_Max
Visibility = Visibility_Max
EndIf
Visibility(Visibility)
EndIf
Else
If Display_Parameters
MouseLocate(MouseX_Start + MouseX - Display_Center_X, MouseY_Start + MouseY - Display_Center_Y)
EndIf
Display_Parameters = 0
EndIf
;}
; If Start3D()
;- Affichage des étoiles
; Initialisation de la recherche de l'étoile la plus proche de la souris
Search_Distance = #Star_Image_Size * #Star_Image_Size
*Search_LastStar = *Search_Star
*Search_Star = 0
Star_Display_Counter = 0
; Rotation du repère
Rotate_Axis_Y(@Repere, Angle_RA_Speed)
Rotate_Axis_X(@Repere, Angle_DE_Speed)
; Pour chaque étoile
ForEach Star()
If Star()\Light > Star_Display_MinimumLight
XYZ(@Repere, @Star()\Position, @Star()\Display)
; Affichage de l'étoile, si elle est sur l'écran et visible
If Star()\Display\z < -0.1
Star()\Display\x * Atmosphere
Star()\Display\y * Atmosphere
Star()\Display\z * Atmosphere
If Star()\Display\x >= Display_Screen_XMin And Star()\Display\x < Display_Screen_XMax And Star()\Display\y >= Display_Screen_YMin And Star()\Display\y < Display_Screen_YMax
Star_Display_ScreenX = Star_Display_Center_X + Star()\Display\x
Star_Display_ScreenY = Star_Display_Center_Y + Star()\Display\y
Star_Display_Counter + 1
DisplaySprite(#StarImage3D + Star()\Light, Star_Display_ScreenX, Star_Display_ScreenY)
; Recherche de l'étoile la plus proche de la souris
Star_Display_ScreenX - Star_Display_MouseX
If Star_Display_ScreenX < #Star_Image_Size
Star_Display_ScreenY - Star_Display_MouseY
If Star_Display_ScreenY < #Star_Image_Size And Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY < Search_Distance
*Search_Star = @Star()
Search_Distance = Star_Display_ScreenX * Star_Display_ScreenX + Star_Display_ScreenY * Star_Display_ScreenY
EndIf
EndIf
EndIf
EndIf
EndIf
Next
; Fin de la recherche de l'étoile la plus proche de la souris
If *Search_Star <> *Search_LastStar
Search_Time = ElapsedMilliseconds()
EndIf
If *Search_Star <> 0 And ElapsedMilliseconds() - Search_Time > 250
Search_Display = 1
Else
Search_Display = 0
EndIf
If Display_Parameters
; Affichage des paramètres
DisplaySprite(#Box3D, Display_Zoom_X, Display_Zoom_Y)
DisplaySprite(#Box3D, Display_Visibility_X, Display_Visibility_Y)
Else
If Search_Display
; Affichage de la sélection
DisplaySprite(#Box3D, Display_StarInfo_X, Display_StarInfo_Y)
DisplaySprite(#Selection3D, Display_Center_X + *Search_Star\Display\x - 10, Display_Center_Y + *Search_Star\Display\y - 10)
EndIf
EndIf
; Affichage du pointeur
DisplaySprite(#Pointer3D, MouseX, MouseY)
; Stop3D()
; EndIf
; Texte à afficher
StartDrawing(ScreenOutput())
DrawingMode(#PB_2DDrawing_Transparent)
DrawingFont(FontID(0))
If Display_Parameters ; Affichage des paramètres
Display_Zoom_Text = "Zoom x" + StrD(Atmosphere / Atmosphere_Min, 1)
DrawText(Display_Zoom_CX - TextWidth(Display_Zoom_Text) / 2, Display_Zoom_CY - TextHeight(Display_Zoom_Text) / 2, Display_Zoom_Text, $FFFFFF)
Display_Visibility_Text = "Visibilité = " + StrD(100 * (Visibility - Visibility_Min) / (Visibility_Max - Visibility_Min), 0) + "%"
DrawText(Display_Visibility_CX - TextWidth(Display_Visibility_Text) / 2, Display_Visibility_CY - TextHeight(Display_Visibility_Text) / 2, Display_Visibility_Text, $FFFFFF)
ElseIf Search_Display ; Position de l'étoile sélectionnée
DrawText(Display_StarInfo_CX - TextWidth(*Search_Star\Description) / 2, Display_StarInfo_CY - TextHeight(*Search_Star\Description) / 2, *Search_Star\Description, $FFFFFF)
EndIf
If DebugMode
; Debogage
DrawText(0, 0, "FPS : " + StrD(FPS, 1) + " ; " + StrD(100 * FPS / Screen_Frequency, 1) + "%")
DrawText(0, 20, "Synchronisation : " + Str(Screen_Synchronization) + " (F2 pour changer)")
DrawText(0, 40, "Etoiles calculées : " + Str(Star_Calculation_Counter))
DrawText(0, 60, "Etoiles affichées : " + Str(Star_Display_Counter))
If *Search_Star <> 0
DrawText(0, 80, "Etoile angle RA : " + StrD(*Search_Star\AngleRA))
DrawText(0, 100, "Etoile angle DE : " + StrD(*Search_Star\AngleDE))
EndIf
EndIf
StopDrawing()
;{- Modification de la vitesse de rotation de l'affichage
Angle_DE_Speed * Display_Brake ; Le ralentissement est calculé en même temps que le FPS car il dépend du FPS (le ralentissmeent est le même qlque soit le FPS
Angle_RA_Speed * Display_Brake
;}
FlipBuffers()
;{ Calcul du FPS
FPS_Counter + 1
If FPS_Counter >= FPS
FPS = FPS_Counter * 1000 / (ElapsedMilliseconds() - FPS_ElapsedTime)
FPS_Counter = 0
FPS_ElapsedTime = ElapsedMilliseconds()
If FPS <= 0
FPS = 1
EndIf
Display_Brake = Pow(#Display_Speed_Brake,(1 / FPS)) ; En ralentissant le mouvement de cette manière, on ne tient pas compte du FPS
EndIf
;}
If KeyboardPushed(#PB_Key_Escape) Or IsScreenActive() = 0 ; Fermer si Echap ou retour à Windows
End
EndIf
ForEver
; On change la synchronisation de l'écran
CloseScreen()
Select Screen_Synchronization
Case #PB_Screen_NoSynchronization
Screen_Synchronization = #PB_Screen_WaitSynchronization
Case #PB_Screen_WaitSynchronization
Screen_Synchronization = #PB_Screen_SmartSynchronization
Case #PB_Screen_SmartSynchronization
Screen_Synchronization = #PB_Screen_NoSynchronization
EndSelect
ForEver
venom a écrit :Peut être Dobro alias zorro ou spock Je sais qu'il sauvegarde plein de codes et autre. Il doit avoir une mine de code dans son disque dur