Blog brzegatora27

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

2011-01-14T13:42:00.000-08:00

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

Podsumowanie roku 2010 i przedstawienie planów na rok 2011

2011-01-08T05:16:00.000-08:00

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

SymFiz 2.0 - budowa programu

2010-09-25T11:50:00.000-07:00

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.

Poznajemy DWM(Desktop Window Manager) #1 Aero Glass

2010-08-30T12:08:00.000-07:00

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:  }

Kontrolki WPF w aplikacji Windows Forms

2010-08-29T08:42:00.000-07:00

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:

Kurs WPF 3D cz. 1 - Wprowadzenie

2010-08-28T14:56:00.000-07:00

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. :)

Planowane możliwości programu SymFiz 2.0

2010-08-24T13:15:00.000-07:00

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. :)

Hello world!

2010-08-16T07:12:00.000-07:00

Witam Wszystkich na moim blogu. Powstał on w związku z moim uczestnictwem w konkursie "Daj się poznać!" organizowanego przez Macieja Aniserowicza. Będę na nim opisywał moje zmagania z programem jednocześnie próbując Wam przekazać trochę informacji o technologiach, w których będę tworzył program.

O mnie

Mam na imię Jakub, a na nazwisko Brzegowski. W Internecie można mnie spotkać pod nickiem brzegator27. Interesuje się programowaniem, a także matematyką i fizyką. Niestety nie jestem zbyt dobry z polskiego, dlatego od razu przepraszam za popełnione przeze mnie błędy w pisowni.
Więcej informacji o moich zainteresowaniach możesz uzyskać przez zaglądnięcie do mojego profilu.

O programie

Nazwa programu to SymFiz - skrót od słów symulacje fizyczne. Jak sama nazwa wskazuje program będzie tworzył animacje różnych zjawisk fizycznych. Celem tego programu jest ułatwienie nauczania fizyki, a także ułatwienie tworzenia materiałów np. na potrzeby prezentacji.

Będzie to już druga wersja tego programu - czyli SymFiz 2.0.

Pierwsza wersja została napisana w C++ z użyciem biblioteki Allegro, nie tak dawno pojawiła się także wersja 2.0 beta została napisana także w C++, ale z użyciem Windows API. Te dwie wersje nie były udane, dlatego postanowiłem teraz program napisać praktycznie od nowa w niedawno poznanym języku C#(C Sharp)

Kod programu(prawdopodobnie też jakieś krótkie informacje itp.) o nim będą zamieszczane na tej stronie.

Po zakończeniu konkursu dalej zamierzam rozwijać mój program. Blog najprawdopodobniej będzie także dalej rozwijany.

Więcej o planowanych możliwościach programu, interfejsie itp. napiszę w moim następnym poście. ;)

Technologie w jakich będzie tworzony program...

...to WPF i .NET. Zamierzam Wam przedstawić te technologię. Nie znam ich na razie dobrze, w miarę postępów w nauce będę Wam je przedstawiał i opisywał.

Dodam, że moje środowisko programistyczne to Microsoft Visual C# 2010 Express.

Wygląd bloga

Na razie blog nie wygląda najlepiej i jeszcze nad jego wyglądem itp. będę pracował. Myślę, że już za niedługo wprowadzę na nim trochę zmian.

Po raz pierwszy w swoim życiu piszę swojego własnego bloga i nie mam w tych sprawach doświadczenia. Mam nadzieję, że moje kolejne wpisy będą coraz lepsze i bardziej ciekawe, a Ty będziesz często powracał na mojego bloga i czekał na moje nowe wpisy. :)

Jeśli masz jakieś propozycje dotyczące mojego programu, lub bloga, wykryłeś gdzieś mój błąd, chcesz się o coś mnie zapytać, możesz pisać na tego e-maila: symfiz(at)gmail.com