14 stycznia 2011

Mój udział w konkursach i wiążąca się z tym nauka

Dzisiaj chciałem się z Wami podzielić moimi wynikami w konkursach. Muszę powiedzieć, że ostatnio odnoszę w nich dosyć dobre wyniki. Jak na razie w tym roku szkolnym startowałem w kuratoryjnym konkursie z matematyki, fizyki i astronomii, i informatyki. Konkursy przedmiotowe organizowane przez kuratorium mają charakter trzy etapowy. Pierwszy etap jest szkolny, drugi etap jest rejonowy, a trzeci wojewódzki(będąc zarazem finałem). W konkursie z informatyki, a także fizyki i astronomii udało mi się dojść do etapu wojewódzkiego. Jest to dla mnie duże osiągnięcie, o ile się nie mylę daje mi to już razem +20p na świadectwo(jednak nie jestem pewien – w najbliższym czasie potwierdzę tą informację ;-)). A gra toczy się o wiele większą stawkę i tu cytuję z regulaminu konkursu: 

„Laureaci konkursu przyjmowani będą do wybranej szkoły ponadgimnazjalnej, niezależnie od obowiązujących w niej kryteriów, na mocy § 8 ust.  8  rozporządzenia Ministra  Edukacji Narodowej  i Sportu z dnia 20 lutego 2004 r. w sprawie warunków i trybu przyjmowania uczniów do szkół publicznych oraz przechodzenia z jednych typów szkół do innych (Dz. U. z 2004 r. Nr 26, poz. 232 ze zmianami).”

Laureatami konkursu zostaje 30 osób, które osiągnęły najlepszy wynik w etapie wojewódzkim, a także osoby, które miały idę tyczną liczbę punktów co trzydziesty finalista. Tak więc jak widać jest o co walczyć. Co do konkursu z matematyki to niestety odpadłem już na etapie szkolnym – brakło mi jednego punkta, aby przejść do etapu rejonowego, no niestety.

Co teraz mnie czeka? Tak jak już wspominałem będę miał kuratoryjny przedmiotowy konkurs z informatyki, a także z fizyki i astronomii na etapie wojewódzkim. Oprócz tego będę startował w konkursie fizycznym Lwiątko, a także prawdopodobnie w konkursie matematycznym Kangur.
Do wszystkich konkursów zamierzam się bardzo przyłożyć, w związku z czym praca nad moimi programami zejdzie raczej na boczny plan. Jednak będę się starał mimo wszystko pracować nad nimi intensywnie. ;-)

PS Pochodzę z województwa Małopolskiego, w związku z czym konkursy kuratoryjne organizowanie są Kuratorium Oświaty w Krakowie. ;-)

8 stycznia 2011

Podsumowanie roku 2010 i przedstawienie planów na rok 2011

Witam po bardzo długiej przerwie w blogowaniu. Dzisiaj piszę, aby podsumować rok, który minął 2010 i napisać moje plamy na ten rok, czyli rok 2011.

Ale na początek czas teraźniejszy. W najbliższym czasie będę prawdopodobnie zajęty nauką na konkursy w związku z czym nie będę miał czasu na rozwijanie programu SymFiz i blogowanie. Jednak postaram się, aby z czasem na moim blogu pojawiało się coraz więcej wpisów i były one coraz bardziej wartościowe. :-)

Dobrze, a teraz podsumowanie ubiegłego roku. Ogólnie nie było moim zdaniem za dobrze, ale z drugiej strony nie było tak znowu źle. Niestety nie udało mi się za bardzo rozwinąć mojego głównego programu SymFiz. Nie osiągnąłem także takich postępów w programowaniu jak na początku planowałem. Co poszło dobrze? Huh. Przyznaję nie było tego znowu tak dużo. Zacząłem uczyć się C# i już trochę go umiem. Rozpocząłem także naukę wzorców projektowych, w których nie zrobiłem może dużego postępu, ale mniej więcej się w nich zorientowałem. Poduczyłem się także algorytmiki i napisałem krótki programik MatrixText Hello World(w C#), który generował animację spadających literek jak w matrixie z których pod koniec wyłaniał się napis. Był to program konsolowy. Muszę powiedzieć, że nawet w miarę mi się udał, jednak nie miałem czasu na jego dopracowanie, przez co w paru miejscach jest „brzydko” napisany. W ubiegłym roku nauczyłem się także trochę Windows API, z którego użyciem napisałem pierwszą wersję programu SymFiz. I tak oto nakreśliłem Wam mniej więcej co dokonałem w tym roku.

Teraz kolej na plany tegoroczne. Przyznaję, że chciałbym w tym roku zrobić dużo rzeczy i na 99% im wszystkim nie podołam. Jeśli tak by się stało to ta część planów, które nie udało mi się zrealizować w tym roku zostaną przełożone na następny rok. No, ale do rzeczy. W tym roku chciałbym jak najbardziej rozwinąć swój program SymFiz. Tak, aby zaimplementować już te najważniejsze części programu. W planach mam także stworzenie nowego portalu, wraz z Aleksandrem Zawalichem, ale o tym więcej napiszę w innym wpisie. ;-) Chciałbym także poznać kilka nowych języków i bibliotek, w stopniu dobrym takich jak: VB.NET, VBA, JavaScript, ASP.NET i „liznąć” takie jak: Java, DirectX, QT, WxWidgets, SDL. Zamierzam także pogłębić swoją wiedze w językach, bibliotekach, technologiach itp., które obecnie już trochę znam, czyli HTML, CSS, PHP, C++, C#, Windows API,  a także algorytmika, oraz wzorce projektowe. Pogłębianie mojej wiedzy będzie się zapewne wiązało z rozpoczęciem kilku nowych malutkich projektów. Jeśli takowe powstaną poinformuję o tym na blogu. ;-)

Zamierzam także bardziej uczyć się matematyki, fizyki, języka angielskiego i niemieckiego. Chciałbym także zrobić postępy w tworzeniu grafiki komputerowej.

Tak więc oto są moje plany na ten rok, myślę że są one duże i nie zdołam ich wszystkim podołać w tym roku. Ale jeśli chociaż w większej części uda mi się je zrealizować to będę bardzo zadowolony. Jestem bardzo zdeterminowany, aby wykonać jak najwięcej z postawionych sobie założeń. ;-)

Dlaczego przedstawiłem Wam moje plany na blogu, jaki miałem w tym cel? Główny cel jest taki, że przedstawienie takich planów opinii publicznej bardziej zmotywuje mnie do ich zrealizowania. Drugim, trochę mniej ważnym celem, było po prostu przedstawienie Wam co zamierzam osiągnąć w tym roku.

Kolejne podsumowanie za około rok. ;-) 

25 września 2010

SymFiz 2.0 - budowa programu

Witam ponownie po przerwie – szkoła się zaczęła w związku z czym mam niestety mniej czasu na rozwój projektu. A dzisiaj krótko o tym z czego będzie się „składał” program. Postanowiłem podzielić go na plik .exe i 11 modułów(będących plikami .dll) – moduł:
- ustawień
- zapisu i odczytu
- zadań i wiadomości(opis zjawisk, zadania z fizyki związane z danym zjawiskiem itd.)
- aktualizacji
- pobierania scen, „wzorców” zjawisk fizycznych etc. utworzonych przez innych użytkowników z serwera przez Internet
- moduł tworzenia własnych scen, „wzorców” zjawisk fizycznych etc., z możliwością umieszczania ich na serwerze
- animacji na żywo
- menu
- pomocy dla użytkownika
- generacji animacji zjawisk do pliku .gif itp.
- odczytu plików o rozszerzeniu .gif itp.


To jest taki wstępny zarys, prawdopodobnie budowa się jeszcze zmieni - jestem otwarty na Wasze propozycje. 

Dlaczego postanowiłem go podzielić na takie moduły? Po to, aby praca nad jego rozwojem była łatwiejsza, a także, aby podczas jego aktualizacji podmieniać np. tylko jeden dany plik dll, a nie np. cały plik exe. Oczywiście rozwój wszystkich modułów zajmie mi sporo czasu, dlatego na razie postaram się rozwinąć te najważniejsze.

Dokładniej budowę programu opiszę jeszcze prawdopodobnie w innym wpisie.  

30 sierpnia 2010

Poznajemy DWM(Desktop Window Manager) #1 Aero Glass

Ostatnio zainteresowałem się DWM(czyli Desktop Window Manager), a dokładniej Aero Glass. Postanowiłem bardziej poznać ten graficzny interfejs i Wam go opisać. Jeszcze nie wiem na ile uda mi się go poznać, ale jeśli nauczę się czegoś nowego to opiszę to na moim blogu. Część z tego najprawdopodobniej wykorzystam w moim programie. Dziś opiszę jak uzyskać efekt Aero Glass w oknie.

Program tworze w Microsoft Visual C# 2010 Express i dalej będę się posługiwał nazwami plików tworzonych domyślnie przez to IDE, podczas kreowania aplikacji WPF.

Wprowadzenie
Co to jest DWM? Jest to system GUI(Graphical User Interface) dostępny w Microsoft Windows Vista i Microsoft Windows 7. DWM umożliwia użycie w graficznym interfejsie użytkownika Windows Aero.


Zaczynajmy!
Oto jaki będzie efekt naszej pracy:


Jak to wykonać?
Najpierw stworzymy nową klasę i zincludujemy kilka funkcji z biblioteki dwmapi.dll:

   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Text;
   5:  using System.Runtime.InteropServices;
   6:   
   7:  [StructLayout(LayoutKind.Sequential)]
   8:  struct MARGINS
   9:  {
  10:      public int cxLeftWidth;
  11:      public int cxRightWidth;
  12:      public int cyTopHeight;
  13:      public int cyBottomHeight;
  14:  }
  15:   
  16:  namespace Aero_Glass
  17:  {
  18:      class MyAeroGlass
  19:      {
  20:          [DllImport("dwmapi.dll", PreserveSig = false)]
  21:          static extern void DwmExtendFrameIntoClientArea(
  22:              IntPtr hWnd, ref MARGINS pMarInset);
  23:   
  24:          [DllImport("dwmapi.dll", PreserveSig = false)]
  25:          static extern bool DwmIsCompositionEnabled();
  26:      }
  27:  }

W klasie MyAeroGlass zaimplementujemy teraz metodę ExtendGlassFrame. Po jej implementacji plik z klasą wygląda tak:

   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Text;
   5:  using System.Runtime.InteropServices;
   6:  using System.Windows;
   7:  using System.Windows.Interop;
   8:  using System.Windows.Media;
   9:   
  10:  [StructLayout(LayoutKind.Sequential)]
  11:  struct MARGINS
  12:  {
  13:      public MARGINS(Thickness myThickness)
  14:      {
  15:          cxLeftWidth = (int)myThickness.Left;
  16:          cxRightWidth = (int)myThickness.Right;
  17:          cyTopHeight = (int)myThickness.Top;
  18:          cyBottomHeight = (int)myThickness.Bottom;
  19:      }
  20:   
  21:      public int cxLeftWidth;
  22:      public int cxRightWidth;
  23:      public int cyTopHeight;
  24:      public int cyBottomHeight;
  25:  }
  26:   
  27:  namespace Aero_Glass
  28:  {
  29:      class MyAeroGlass
  30:      {
  31:          [DllImport("dwmapi.dll", PreserveSig = false)]
  32:          static extern void DwmExtendFrameIntoClientArea(
  33:              IntPtr hWnd, ref MARGINS pMarInset);
  34:   
  35:          [DllImport("dwmapi.dll", PreserveSig = false)]
  36:          static extern bool DwmIsCompositionEnabled();
  37:   
  38:          public static bool ExtendGlassFrame(Window window, Thickness thickness)
  39:          {
  40:              //Sprawdzmy, czy system jest starszy niż Windows Vista - jeśli tak 
  41:              //to zwracamy false i kończymy pracę pętli
  42:              //Sprawdzmy także, czy kompozyty DWM są włączone - jeśli nie 
  43:              //to zwracamy false i kończymy pracę pętli
  44:              if (Environment.OSVersion.Version.Major < 6 || !DwmIsCompositionEnabled()) return false;
  45:   
  46:              //Pobiermay uchwyt okna i sprawdzamy, czy ono(okno) istnieje
  47:              WindowInteropHelper hWnd = new WindowInteropHelper(window);
  48:              if (hWnd.Handle == IntPtr.Zero) return false;
  49:   
  50:              //Tło ustalamy na transparent
  51:              window.Background = Brushes.Transparent;
  52:              HwndSource.FromHwnd(hWnd.Handle).CompositionTarget.BackgroundColor = Colors.Transparent;
  53:   
  54:              MARGINS myMargins = new MARGINS(thickness);
  55:   
  56:              DwmExtendFrameIntoClientArea(HwndSource.FromHwnd(hWnd.Handle).Handle, ref myMargins);
  57:   
  58:              return true;
  59:          }
  60:      }
  61:  }

Następnie przesłaniamy metodę OnSourceInitialized:

   1:  protected override void OnSourceInitialized(EventArgs e)
   2:          {
   3:              base.OnSourceInitialized(e);
   4:   
   5:              bool mybool = MyAeroGlass.ExtendGlassFrame(this, new Thickness(-1));
   6:          }

Teraz plik MainWindow.xaml.cs wygląda tak:

   1:  using System;
   2:  using System.Windows;
   3:   
   4:  namespace Aero_Glass
   5:  {
   6:      /// <summary>
   7:      /// Interaction logic for MainWindow.xaml
   8:      /// </summary>
   9:      public partial class MainWindow : Window
  10:      {
  11:          public MainWindow()
  12:          {
  13:              InitializeComponent();
  14:          }
  15:   
  16:          protected override void OnSourceInitialized(EventArgs e)
  17:          {
  18:              base.OnSourceInitialized(e);
  19:   
  20:              bool mybool = MyAeroGlass.ExtendGlassFrame(this, new Thickness(-1));
  21:          }
  22:      }
  23:  }

29 sierpnia 2010

Kontrolki WPF w aplikacji Windows Forms

Postanowiłem napisać o tym, jak umieścić kontrolki WPF w aplikacji Windows Forms. Być może ktoś chciałby zmieścić np. kontrolkę Viewport w aplikacji WF, lub jakąś inną kontrolkę, dlatego to opiszę. Stworzymy przykładową aplikację Windows Forms, w której będzie wyświetlany nasz niebieski trójkąt z poprzedniego wpisu, a także kontrolke TextBox z WPF. Program będzie tworzony w Microsoft Visual C# 2010 Express i dalej będę się posługiwał nazwami plików tworzonych domyślnie przez to IDE, podczas tworzenia aplikacji WF.

Formalności mamy już za sobą więc zaczynajmy.

Na początek dołączymy dwie referencje do projektu: WindowsFormsIntegration i System.Xaml. W tym celu klikamy prawym przyciskiem myszy na "references" i wybieramy "Add Reference..."


Pojawi się nam okienko, w którym wybieramy te dwa komponenty(WindowsFormsIntegration i System.Xaml) i klikamy przycisk OK.



Kontrolka ElementHost

W Windows Forms istnieje specjalna kontrolka ElementHost, w której można umieścić kontrolkę WPF. W przykładowym programie będą dwie kontrolki WPF, więc dołączymy dwie kontrolki ElementHost. Otwieramy plik Form1.cs[Design], wybieramy z okienka Toolbox zakładkę WPF Interoperability i wybieramy kontrolkę ElementHost.


Umieszczamy je(kontrolki ElementHost) w naszym oknie.

Do aplikacji dodajemy nowy plik, będzie to User Control(WPF). Nazywamy ją na przykład MyWPFUserControl.xaml. Podczas tworzenia pliku nasze IDE automatycznie doda trzy referencje do naszego projektu, będzie to: PresentationCore, PresentationFramework i WindowsBase.

Kontrolka będzie wyświetlała nasz niebieski trójkąt z wpisu: Kurs WPF 3D cz. 1 - Wprowadzenie. Oto nasz kod z pliku MyWPFUserControl.xaml:

   1:  <UserControl x:Class="WPF_Control_in_WF_Application.MyWPFUserControl"
   2:               xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   3:               xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   4:               xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
   5:               xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
   6:               mc:Ignorable="d" 
   7:               d:DesignHeight="300" d:DesignWidth="300">
   8:      <Viewport3D>
   9:          <Viewport3D.Camera>
  10:              <PerspectiveCamera 
  11:                      Position="10,10,10" 
  12:                      LookDirection="-10,-10,-10" 
  13:                      UpDirection="0,1,0"
  14:                      FieldOfView="50" />
  15:          </Viewport3D.Camera>
  16:          <Viewport3D.Children>
  17:              <ModelVisual3D>
  18:                  <ModelVisual3D.Content>
  19:                      <AmbientLight Color="White"/>
  20:                  </ModelVisual3D.Content>
  21:              </ModelVisual3D>
  22:              <ModelVisual3D>
  23:                  <ModelVisual3D.Content>
  24:                      <Model3DGroup>
  25:                          <GeometryModel3D>
  26:                              <GeometryModel3D.Material>
  27:                                  <DiffuseMaterial Brush="Blue"/>
  28:                              </GeometryModel3D.Material>
  29:                              <GeometryModel3D.Geometry>
  30:                                  <MeshGeometry3D 
  31:                                          Positions="0,0,0 5,0,0 0,5,0"
  32:                                  TriangleIndices="0 1 2" />
  33:                              </GeometryModel3D.Geometry>
  34:                          </GeometryModel3D>
  35:                      </Model3DGroup>
  36:                  </ModelVisual3D.Content>
  37:              </ModelVisual3D>
  38:          </Viewport3D.Children>
  39:      </Viewport3D>
  40:  </UserControl>

Następnie ustawiamy zawartość naszej pierwszej kontrolki ElementHost na MyWPFUserControl:


Potem klikamy prawym przyciskiem myszy na plik Form1.cs i wybieramy View Code. Z poziomu kodu C# dodajemy do drugiej kontrolki ElementHost kontrolkę Grid z WPF w której będzie kontrolka TextBox. Oto nowy kod w pliku Form1cs:

   1:  using System.Windows.Forms;
   2:   
   3:  namespace WPF_Control_in_WF_Application
   4:  {
   5:      public partial class Form1 : Form
   6:      {
   7:          public Form1()
   8:          {
   9:              InitializeComponent();
  10:   
  11:              System.Windows.Controls.Grid myGrid = new System.Windows.Controls.Grid();
  12:              System.Windows.Controls.TextBox myTextBox = new System.Windows.Controls.TextBox();
  13:              myTextBox.Height = 67;
  14:              myTextBox.Width = 326;
  15:              myTextBox.Text = "Jestem kontrolką WPF :)";
  16:   
  17:              myGrid.Children.Add(myTextBox);
  18:   
  19:              elementHost2.Child = myGrid;
  20:          }
  21:      }
  22:  }

Po uruchomieniu nasza aplikacja wygląda tak:

28 sierpnia 2010

Kurs WPF 3D cz. 1 - Wprowadzenie

Ten wpis rozpoczyna nową serię moich wpisów na blogu dotyczących WPF 3D. Będzie to mały kurs i wstęp do tej technologi, dla ludzi jej nie znających. Postaram się systematycznie publikować nowe wpisy z tej serii. Ten wpis będzie wprowadzeniem do tego tematu. Następne wpisy będą bardziej szczegółowe - ten będzie takim bardzo krótkim wprowadzeniem.


Elementy 3D, a elementy 2D

Elementy 3D bezproblemowo współgrają z innymi elementami aplikacji. Elementy 3D mogą być bezproblemowo wyświetlane na powierzchni elementów 2D i vice versa. Aplikacje WPF 3D można tworzyć w XAML, lub bezpośrednio z kodu programu.


Prosta aplikacja

Na początek przedstawię kod prostej aplikacji, która wyświetla niebieski trójkąt. Oto kod:
   1:  <Window x:Class="WPF3DFirstApplication.MainWindow"
   2:          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   3:          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   4:          Title="MainWindow" Height="350" Width="525">
   5:      <Grid>
   6:          <Viewport3D>
   7:              <Viewport3D.Camera>
   8:                  <PerspectiveCamera 
   9:                      Position="10,10,10" 
  10:                      LookDirection="-10,-10,-10" 
  11:                      UpDirection="0,1,0"
  12:                      FieldOfView="50" />
  13:              </Viewport3D.Camera>
  14:              <Viewport3D.Children>
  15:                  <ModelVisual3D>
  16:                      <ModelVisual3D.Content>
  17:                          <AmbientLight Color="White"/>
  18:                      </ModelVisual3D.Content>
  19:                  </ModelVisual3D>
  20:                  <ModelVisual3D>
  21:                      <ModelVisual3D.Content>
  22:                          <Model3DGroup>
  23:                              <GeometryModel3D>
  24:                                  <GeometryModel3D.Material>
  25:                                      <DiffuseMaterial Brush="Blue"/>
  26:                                  </GeometryModel3D.Material>
  27:                                  <GeometryModel3D.Geometry>
  28:                                      <MeshGeometry3D 
  29:                                          Positions="0,0,0 5,0,0 0,5,0"
  30:                                  TriangleIndices="0 1 2" />
  31:                                  </GeometryModel3D.Geometry>
  32:                              </GeometryModel3D>
  33:                          </Model3DGroup>
  34:                      </ModelVisual3D.Content>
  35:                  </ModelVisual3D>
  36:              </Viewport3D.Children>
  37:          </Viewport3D>
  38:      </Grid>
  39:  </Window>
A oto jego efekty:
Jak można zauważyć swego rodzaju kontenerem dla świata 3D jest element Vievport3D. To w nim znajdują się wszystkie inne elementy świata 3D, takie jak:
- Kamera - do dyspozycji mamy trzy rodzaje kamery: PerspectiveCamera, OrthographicCamera i MatrixCamera.
- Oświetlenie - istnieją cztery rodzaje oświetlenia: AmbientLight, DirectionalLight, PointLight i SpotLight.
- Model


To był bardzo krótki i ogólny wstęp, jednak postaram się, aby następne wpisy były bardziej szczegółowe i opisywały dokładniej zagadnienia. Prawdopodobnie już za niedługo kolejny wpis z tej serii, a także inne. Jestem początkującym i dopiero od niedawna "wgryzam się" w temat, dlatego ten wpis jest taki krótki - następne będą lepsze. :)

24 sierpnia 2010

Planowane możliwości programu SymFiz 2.0

Przepraszam, za to, że w tamtym tygodniu napisałem tylko jeden wpis na moim blogu, za to w tym postaram się to nadrobić z nawiązką. ;) A dzisiaj krótki wpis, o tym, jakie są planowane możliwości programu SymFiz 2.0. W moim wcześniejszym wpisie napisałem trochę o tym, jakie są cele projektu. Teraz więcej szczegółów. Nie wiem w ilu procentach uda mi się zrealizować plany podczas trwania konkursu "Daj się poznać!" organizowanego przez Macieja Aniserowicza, w każdym razie jeśli mi się czegoś nie uda zrobić w tym terminie to najprawdopodobniej zrobię to później – ponieważ aplikacja będzie dalej rozwijana(przynajmniej na razie takie są moje plany).



Oto lista planowanych możliwości programu SymFiz 2.0:
  • Informacje o danych zjawiskach fizycznych
  • Przykładowe zadania za każdym razem losowane i pobierane z serwera    
  • Folder domyślny utworzony w folderze Dokumenty noszący nazwę SymFiz, w którym będą zapisywane różne pliki np. animacje utworzone przez program, oczywiście będzie można wybrać inny folder i wskazać go programowi podczas tworzenia animacji
  • Możliwość zapisu animacji jako pliku .gif
  • Zapisania dowolnej klatki animacji jako pliku .gif
  • Animacja w 3D
  • Animacja w 2D
  • Możliwość zmiany koloru ciała
  • Możliwość ustawienia bitmapy jako ciała:
    - jeśli użytkownik wybierze tą opcję to musi ustalić środek ciała
    - można wybrać czy chce się, aby program narysował kontury
  • Możliwość animacji na wielu oknach
  • Możliwość animowania kilku zjawisk na raz
  • Możliwość tworzenia wykresów
    - w tym możliwość wybrania dowolnych ciał branych pod uwagę przy rysowaniu wykresu
  • Możliwość umieszczenia wykresów itp. w animacji(miałyby się one zmieniać wraz z animacją)
  • Możliwość anulowania symulacji w każdej chwili
  • Możliwość zatrzymania(bez anulowania) animacji w każdej chwili
  • Możliwość cofnięcia symulacji do dowolnej chwili
  • Możliwość przewinięcia symulacji do dowolnej chwili
  • Możliwość wstrzymania symulacji na określony czas w określonym wcześniej czasie
  • Przy widoku 3D możliwość wybrania jak obserwować ciało
  • Możliwość rysowania toru ruchu wybranego ciała
  • Możliwość rysowania wektorów wybranego ciała
  • Możliwość wyboru podziałki:
    a) Dynamiczna – polegająca na tym, że jest obliczana tak, aby animacja zmieściła się na ekranie(oknie)
    b) Stała – odległości w rzeczywistości odpowiada zawsze taka sama liczba pieli na ekranie
         - Jeśli animacja się nie mieści użytkownik ma możliwość przewinięcia w górę, lub w dół
         - Możliwość ustawienia np. ilu metrom w terenie odpowiada ile pikseli na ekranie
  • Własny typ zapisu


Będą one także dostępne na oddzielnej stronie na tym blogu. Co jakiś czas prawdopodobnie będę dodawał nowe planowane możliwości programu, jeśli się takowe pojawią, a także odhaczał, te, które udało mi się już zrealizować. ;)

Obecne planowane możliwości zostały tylko wymienione(czasami trochę opisane), wraz z czasem i ich realizacją będę prawdopodobnie je konkretyzował i opisywał.

Jeśli macie jakieś ciekawe propozycje dotyczące mojego programu możecie pisać na tego e-maila: symfiz[at]gmail.com, lub po prostu zamieszczać je w komentarzach pod wpisami. :)