wtorek, 11 listopada 2014

Trwają otwarte testy gry The Talos Principle

Do 11 grudnia można testować darmową wersję The Talos Principle. Wg opisu na Steamie, TTP jest "filozoficznymi pierwszoosobowymi puzzlami". Mówiąc jaśniej, gra jest nieco podobna do Portala czy Antichamber, jednak osadzona w całkiem innym świecie.


Jaki jest sens wersji testowej?

Wersja testowa zawiera tylko 4 z 120 zagadek i starcza na 20-90 minut. Została wydana jednocześnie na Linuksa, Windows i OS X, w celu znalezienia błędów przed ukazaniem się pełnej gry 11 grudnia 2014. To miła odmiana w czasach, gdy króluje płatny "wczesny dostęp" i nikt nie chce wydawać bezpłatnych wersji demonstracyjnych.
Twórcy reagują na bieżąco na zgłaszane błędy i wydają poprawki.

Rozgrywka

Ciekawostką jest, że wstępne testy rozgrywki wykonał bot. I chyba zrobił to nieźle, bo większości ludzi (w tej chwili wg Steam "Recenzje użytkowników: Przytłaczająco pozytywne (782)") gra się podoba.
Mnie urzekła możliwość rozwiązywania zagadek w różnej kolejności i na różne sposoby. Mimo częstych porównań do Portala 2 (tu i tu są lasery i kostki), obie gry znacznie się różnią. W Portalu niemal wszystko było jasne od początku do końca, komory testowe były hermetyczne i pokonywane sekwencyjnie, a każda z nich miała zwykle tylko jedno rozwiązanie.
W The Talos Principle alternatywne rozwiązania nie są błędami w grze, można ukończyć "komorę" wykorzystują zaledwie część dostępnych narzędzi, a czasami nawet pomóc sobie czymś (jak promień lasera) z zewnątrz. Narracja póki co zadaje więcej pytań niż daje odpowiedzi. Ah, i nasz bohater ma ręce, którymi chwyta przedmioty.

Specjalnie dla Polaków

Miłym akcentem w pełnej wersji (dostępnej tutaj) będzie pełna polska wersja językowa (zarówno dźwięk jak i napisy). I, co się rzadko zdarza na Steamie, nie zapomniano że zarabiamy trochę mniej niż na Zachodzie. Obecnie cena pre-orderu TTP dla Europy Wschodniej to 18 euro (17, gdy ma się w bibliotece grę SS3, Antichamber lub Swapper), dwa razy mniej niż na Zachodzie.

Grafika i wymagania

Grafika wygląda dobrze, a jeśli weźmiemy pod uwagę, że to gra zrobiona w niecałe 2 lata przez kilka osób, to można powiedzieć, że wyśmienicie. TTP to pierwsza gra wydana na Serious Engine 4. Pomimo tego, wymagania są akceptowalne - jeśli kogoś nie zraża "kinowa" prędkość renderingu, to może swobodnie grać nawet na zintegrowanym Intelu HD 4000 przy niskich ustawieniach detali. Nawet wtedy gra wygląda całkiem znośnie - na pewno znacznie lepiej (szczególnie w kwestii tekstur, mapowania paralaksy czy roślinności) niż Serious Sam 3 (SE3.5). Wydajność wydaje się jednocześnie nieco wyższa niż starszej gry Croteam.
Pomimo usilnych prób, nie udało mi się znaleźć żadnych błędów wyświetlania grafiki na różnych konfiguracjach sprzętowych (Nvidia - binarny, Intel i AMD - otwarte). Poważnie!

Jak przystało na Chorwatów, dostępne są dziesiątki ustawień graficznych i rozgrywki. Można dostosować nawet prędkość biegu bohatera.

Gra ma wbudowany benchmark, który się odblokowuje po ukończeniu poziomu, aby zapobiec zobaczeniu spoilerów przez gracza - w czasie testu to bot rozwiązuje zagadki. Blokadę można ominąć wpisując w konsoli:

prj_bAllowAutomatedBenchmark=1

TTP jest w mojej opinii jedynym, obok Unigine, współczesnym benchmarkiem dostępnym na Linuksa.

Dodatkowa promocja

Jeśli komuś spodobało się układanie tetromino, to powinien pobrać minigrę Sigils of Elohim. Za wykonanie układanek z klocków jesteśmy tam nagradzani kodami, które mogą być wykorzystane w pełnej wersji TTP (w której ma być stosunkowo niewiele takich puzzli).
Trwa też konkurs, w którym rozdawane są różne gry Devolver Digital - zasady można znaleźć tutaj.

niedziela, 26 października 2014

Wydajnośc gier na Linuksie jest mierna. Niezależnie od producenta GPU.

Spalcie heretyka, ale nawet mój największy entuzjazm dla Linuksa nie może przysłaniać rzeczywistości. Jestem w stanie wypowiadać się o graniu na Linuksie w samych superlatywach, za wyjątkiem oceny wydajności renderingu.

Prawie dwa lata temu Alen Ladavac napisał:
There's this strange situation with OpenGL drivers ATM, especially on Linux. Strictly speaking, latest NVidia driver itself is slightly faster in OpenGL/Linux, than in Windows/D3D. However, seems that shader performance when running with it is much lower. This is the 50% speed difference people are talking about. Shader performance is largely a factor of shader compiler embedded in the driver.

Streszczając, problemem była wydajność shaderów (tych małych programików w GLSL, które są wykonywane na GPU) - jakieś 50% niższa niż w przypadku Direct3D/HLSL. Niektórzy pewnie uznali wtedy Alena za amatora, a Serious Engine za szajs - w końcu Valve twierdziło, że gry na OpenGL działają szybciej. Ja wiedziałem, że coś jest na rzeczy, w końcu Croteam z Alenem na czele pisało gry na OpenGL od ponad dekady i trudno było im odmówić doświadczenia.

Jak czas zweryfikował te słowa? Kilka benchmarków współczesnych gier AAA zrobionych przez społeczność PCGamingWiki:
Gry zostały przeniesione przez rożne zespoły (Feral, Aspyr) i łączą je dwie rzeczy: bezproblemowość/stabilność i... o ok. 50% niższa wydajność niż na Windows. Wszystkie testy zostały wykonane na GPU Nvidii. Postępu brak.

I nie jest to problem Linux vs Windows a OpenGL vs Direct3D (precyzyjniej GLSL vs HLSL) - sterownik binarny Nvidii jest zunifikowany i zapewnia w zasadzie tę samą wydajność w OpenGL na Linuksie jak i Windows.

Valve twierdzi, że OpenGL jest szybszy, o co tu chodzi? Tutaj posłużę się cytatem z wypowiedzi kolejnego programisty Croteam, Deana Sekulica:
We now have DX11 path (still in beta, yes) to compare performance with other gfx APIs. And I have to admit - I'm not very pleased with that I saw (measure) for now; DX11 is not much faster then DX9. Not as much as MS/NV/ATI wanted us to believe. :( OpenGL (on NV, not ATI!) is still the king of performance when you're CPU limited. :)
Teraz wszystko wydaje się jasne, OpenGL jest wydajniejszy, gdy wąskim gardłem jest CPU. Mniejszy narzut na CPU i to "całe AZDO" o którym tyle Intel/AMD/Nvidia mówi ostatnio.  Nienajnowsze już gry Valve są zdecydowanie zbyt mało wymagające by GPU (nie CPU) stało się dla nich wąskim gardłem.  Szczególnie, że ich wyniki pochodzą z testów przy rozdzielczości 1280 x 1024 (!).

Koniec części merytorycznej/na temat części posta

Nie zamierzam jednak tutaj płakać. Poza mizerną wydajnością, granie na Linuksie to niemal sama przyjemność. Pierwszy raz wszystko czego wymaga się od użytkownika to wykonania dwóch kroków: kliknięcia "Instaluj" i potem "Graj". Żadnych instalacji DirectX czy vcredist dla każdej z gier z osobna, jak na Windows. Do tego dźwięk HRTF. Miód.
Wybór gier jest też coraz większy, nawet z wyborem AAA nie jest już fatalnie. Ba, mogę nawet sromotnie przerżnąć partyjkę w UT(2014), bez płacenia grosza.

W końcu nawet do Oculus SDK w wersji 0.4.3 powróciła obsługa Linuksa. Problem w tym, że konsumencka wersja Rifta będzie wymagała GPU wydajnego w bardzo wysokich rozdzielczościach. Celem musi być jakieś 90 kl./s w 4K dla gier na Unreal Engine 4. I tradycyjne SLI nie wchodzi w UE4 w grę (słowo klucz: deferred rendering).

Spokojnie czekam na lepsze sterowniki, może lepsze API. Mam kupę gier w bibliotece Steam by sobie to czekanie umilić. Ostatni strzał: Dead Island. Port świetny, ale jakość samej gry... trudno mi ten niski FOV, blur, oślepiający bloom, konsolowe wybieranie broni, przyspieszenie myszki i gumowe sterowanie skomentować - Techland, co wyście sobie myśleli?

PS Wszystkie testy w 1280 x 1024, niezależnie czy wykonane przez Valve czy na naszym krajowym podwórku, są tylko marnowaniem czasu. Gdzieś w 1999 roku Secret Service chwaliło się, że jak dorwali TNT2 do testów to Quake1 2 leciał płynnie w 1600 x 1200 x 32. Chyba nastąpił jakiś postęp przez ostatnie 15 lat?


sobota, 23 sierpnia 2014

Prosta instalacja natywnego Direct3D9 (Gallium Nine) na Ubuntu

Użytkownik Ubuntu zwykle nie musi znać metod kompilacji, systemów kontroli wersji czy nakładania łatek. Życie ratują mu repozytoria PPA. Tak jest i tym razem.

Omówię tutaj instalację i uruchomienie implementacji Direct3D dla sterowników korzystających z modelu Gallium, czyli niemal wszystkich (AMD - R600g/radeonsi, Nvidia -  nouveau) otwartych za wyjątkiem oficjalnego sterownika Intela (i965). W tym ostatnim przypadku również istnieje furtka, czyli sterownik LunarG ilo.

O co chodzi z Gallium Nine

Model sterowników Gallium 3D rozdziela część odpowiedzialną za współpracę ze sprzętem od implementacji API graficznego. Dzięki temu można małym nakładem sił dodać kolejne API do wszystkich sterowników korzystających z tego modelu. Do tej pory jedynym zaimplementowanym API było OpenGL, Gallium Nine wprowadziło obsługę (znanego dotychczas z Windows) Direct3D 9.

Oczywiście na chwilę obecną nie ma na Linuksie natywnych gier korzystających z D3D. Za to Gallium Nine przynosi znaczące korzyści w grach i aplikacjach z Windows uruchamianych pod Wine. Dotychczas działały one w następujący sposób:

Program->D3D(Wine)->OpenGL->Sterownik(Gallium)->Sprzęt

Teraz pozbyto się etapu tłumaczenia D3D an OpenGL i zostało:

Program->D3D(Wine)->Sterownik(Gallium)->Sprzęt

Korzyścią jest przede wszystkim zwiększona ok. dwukrotnie wydajność i czasami uniknięcie błędów wyświetlania. Np. Bioshock przyspieszył z 20-50 kl/.s (1920x1080, wysokie detale, HD6670)) do 35-100 kl./s, a bąble powietrza w wodzie przestały powodować artefakty. Oczywiście ta implementacja nie jest jeszcze dopracowana i niektóre gry, jak Metro 2033, odmawiają współpracy.

Instalacja

Potrzebujemy dwóch repozytoriów PPA: ppa:oibaf/graphics-drivers zawierającego sterowniki z Gallium Nine i ppa:commendsarnex/ppa ze zmodyfikowaną wersją Wine. Uwaga: repozytoria przeznaczone są dla Ubuntu 14.04 i 14.10.


Dodajemy repozytoria, aktualizujemy sterowniki i instalujemy Wine:

sudo apt-add-repository ppa:oibaf/graphics-drivers
sudo apt-add-repository ppa:commendsarnex/ppa
sudo apt-get update
sudo apt-get dist-upgrade
sudo apt-get install wine1.7 

Aktualizacja (31.08.2014): w tym momencie koniecznie jest dodanie jeszcze repozytorium ppa:commendsarnex/galliumnine, bo Nine jest tymczasowo usunięte z PPA Oibafa na skutek problemów ze sterownikiem nouveau.

sudo apt-add-repository ppa:commendsarnex/galliumnine

Oczywiście wszystkie powyższe kroki można wyklikać w Synapticu (Ustawienia->Repozytoria->Inne Oprogramowanie->Dodaj itd.)

Jeśli coś pójdzie nie tak, to repozytoria PPA można całkowicie usunąć korzystając z ppa-purge:

sudo apt-get install ppa-purge
sudo ppa-purge ppa:oibaf/graphics-drivers
sudo ppa-purge ppa:commendsarnex/ppa 

Pozostaje jeszcze jeden ważny krok, czyli modyfikacja rejestru Wine. Uruchamiamy Regedit:

wine regedit

i tworzymy klucz:

HKEY_CURRENT_USER->Software->Wine->Direct3D

a w nim wartość DWORD równą 1


Pozostaje zrestartować komputer i zabrać się za testy.

Sprawdzenie działania

Zacznijmy od sprawdzenia czy sterownik Gallium został prawidłowo zaktualizowany:

glxinfo | grep OpenGL

powinno dać coś w stylu (zwróć uwagę na "gallium-nine"):

OpenGL vendor string: X.Org
OpenGL renderer string: Gallium 0.4 on AMD TURKS
OpenGL core profile version string: 3.3 (Core Profile) Mesa 10.4.0-devel (git-e7f2f2d 2014-08-22 trusty-oibaf-ppa+gallium-nine)
OpenGL core profile shading language version string: 3.30
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL core profile extensions:
OpenGL version string: 3.0 Mesa 10.4.0-devel (git-e7f2f2d 2014-08-22 trusty-oibaf-ppa+gallium-nine)
OpenGL shading language version string: 1.30
OpenGL context flags: (none)
OpenGL extensions:
OpenGL ES profile version string: OpenGL ES 3.0 Mesa 10.4.0-devel (git-e7f2f2d 2014-08-22 trusty-oibaf-ppa+gallium-nine)
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.0
OpenGL ES profile extensions:

Teraz można uruchomić jakąś grę korzystającą z Direct3D, można od razu włączyć wyświetlanie klatek na sekundę:

GALLIUM_HUD=fps wine naszagra

Jak sprawdzić czy Gallium Nine na pewno jest używane? Wystarczy zobaczyć czy nasza program/gra korzysta z pliku libd3dadapter:

lsof | grep libd3d

co powinno dać wynik jak na poniższym zrzucie:



Może zdarzyć się, że jakiś program nie chce współpracować z Gallium Nine. Wtedy zmiana wcześniej utworzonej przez nas w Regedicie wartości DWORD na 0 przywróci tradycyjną warstwę tłumaczenia D3D-OGL.

Co ze sterownikami binarnymi?

Te oczywiście nie korzystają i raczej nigdy nie będą korzystać z Gallium. Receptą na poprawę wydajności Wine są łatki CSMT, które rozdzielają tłumaczenie D3D->OGL na kilka wątków procesora.

Podziękowania dla /u/sarnex za utworzenie repozytorium i opis konfiguracji Wine.

wtorek, 8 lipca 2014

FreeCAD 0.14 został wydany

Nie wiem czy muszę o tym wspominać, bo program wydaje się znany w Polsce. Dość powiedzieć, że dwa zrzuty ekranu na głównej stronie programu są wynikiem pracy naszych rodaków. Mówię tu o zrzucie przedstawiającym działanie narzędzia EaglePCB_2_FreeCAD (autor: marmni) i modelu lokomotywy (autor: wieszak), jeśli dobrze pamiętam jest to Ty51.

Wracając do tematu. FreeCAD-a 0.14 dzieli od poprzedniej wersji ponad 1800 zmian (commitów), wprowadzonych na przestrzeni nieco ponad roku. Informacje o wydaniu można przeczytać tutaj (polski, w trakcie tłumaczenia) lub tutaj (oryginalny angielski).

Paczkę (tzw. tarball) ze źródłami znajdziecie tutaj, a jeśli korzystacie z Ubuntu, to Normand przygotował dla was PPA. Oczywiście, ci, którzy nie wyznają Kościoła Emacs mogą znaleźć instalatory dla Windows jak i OS X.

Polecam też zwrócić uwagę na zewnętrzne projekty jak BOLTS (biblioteka części znormalizowanych, dostępna też dla OpenSCAD-a jak i jako pliki IGES) czy wtyczkę slicera CuraEngine.
Tę ostatnią można zobaczyć w działaniu na poniższym filmie:

Uprzedzając pytania, nie, nie ma w 0.14 modułu zestawień. Nie ma też nowego modułu dokumentacji (rzutowania 2D). Więcej, jednym z powodów wydania 0.14, były prace nad tymi modułami, które nie mogą być kontynuowane bez czasowego popsucia programu - teraz zwykli użytkownicy mogą używać 0.14, a deweloperzy bezstresowo pracować nad innowacjami.

wtorek, 17 czerwca 2014

FreeCAD: animacja ruchu tłoka i korbowodu sterowana szkicem

Poniżej widoczna jest prosta, sterowana szkicem animacja tłoka i korbowodu. Nie używa ona w ogóle modułu złożeń. Pozycja tłoka oraz pozycja i kąt obrotu korbowodu bazują na pozycji punktów zawartych w pomocniczym szkicu.



Szybka demonstracja

Otwórz plik conrod-piston-anim.fcstd w FreeCAD-zie i wklej do konsoli Pythona następujący skrypt:

import FreeCAD as App, FreeCADGui as Gui, Part, time, sys, math, Draft
from PyQt4 import QtGui,QtCore

class Animation(object):
    def __init__(self):
        App.Console.PrintMessage('init')

        App.ActiveDocument.recompute()

        self.timer = QtCore.QTimer()
        QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.my_update)
        self.timer.start(50)

        self.an = 0.1

    def my_update(self):
        string = '{0}'.format(self.an)
        self.an = self.an + 0.01 if self.an < (2 * math.pi) else 0.0

        angle = math.degrees(self.an)
        App.Console.PrintMessage(str(angle)+" ")
        App.ActiveDocument.getObjectsByLabel("drivingskt")[0].setDatum(5,App.Units.Quantity(str(angle)+' deg'))
        App.ActiveDocument.recompute()
        p1 = App.ActiveDocument.getObjectsByLabel("drivingskt")[0].Shape.Vertexes[0].Point
        p2 = App.ActiveDocument.getObjectsByLabel("drivingskt")[0].Shape.Vertexes[1].Point
        p1t = p1 + App.Vector(0, 37, 0)
        conrodangle = math.degrees(Draft.DraftVecUtils.angle(App.Vector(0, 1, 0),(p1-p2)))
        App.ActiveDocument.getObjectsByLabel("Piston")[0].Placement = App.Placement(p1t,App.Rotation(App.Vector(0, 1, 0), 90))
        App.ActiveDocument.getObjectsByLabel("Conrod")[0].Placement = App.Placement(p2,App.Rotation(App.Vector(0, 0, 1),conrodangle))

    def stop(self):
        self.timer.stop()
       

animation = Animation() 


Powinieneś zobaczyć animację. Możesz ją zatrzymać wpisując:

animation.stop()

Jak to zostało zrobione?

Potrzebne są pliki z modelami korbowodu (conrod) i tłoka (piston):
Otwórz je w FreeCAD-zie i utwórz trzeci, pusty plik. Następnie skopiuj ostatnie cechy z drzew cech tłoka i korbowodu. Wklej je do nowo utworzonego pliku - nazwy cech to odpowiednio "Fusion" i "Pocket002". Potwierdź skopiowanie plików zależnych.

W nowym pliku powinieneś zobaczyć obie części (jak na poniższym zrzucie). Jest kilka drobnych problemów: nie znasz długości korbowodu, pozycji otworu na sworzeń w tłoku, w końcu sam tłok jest obrócony wokół pionowej osi o 90 stopni.
Spróbuj zmienić obrót tłoka regulując wartość "Placement" z karcie Data tab i obserwuj konsolę Pythona. Ustawiając oś obrotu na Y i obracając tłok i 90 stopni powinieneś zobaczyć coś podobnego do:
App.Placement((App.Vector(0, 1, 0),App.Rotation(App.Vector(0, 1, 0), 90))
Pierwszym argumentem jest pozycja tłoka (X, Y, Z), kolejny opisuje oś obrotu (0, 1, 0 to Y), trzecim argumentem jest kąt w stopniach.


Długość korbowodu może zostać zmierzona przy użyciu narzędzi pomiarowych Warsztatu Part. Wybierz dolną ścianę (na stopie) i tworzącą walca otworu na sworzeń.


Jak znaleźć pozycję otworu sworznia w tłoku? Wróć do oryginalnego pliku z tłokiem i poszukaj szkicu użytego do wycięcia otworu lub utworzenia gniazda sworznia.


Zanotuj pozycję szkicu (Sketch004).  Jest on przesunięty -37 mm w kierunku Y. Zauważ, w naszym skrypcie, następującą linię:
p1t = p1 + App.Vector(0, 37, 0)


No koniec, najważniejszy etap, czyli szkic sterujący.Utwórz szkic na płaszczyźnie XY. 


Naszkicuj polilinie jak na powyższym zrzucie (punkt 0, 0 jest środkiem wyimaginowanego wału korbowego, oś pionowa jest osią symetrii cylindra). Zmień więz kąta i obserwuj konsolę Pythona Powinieneś zobaczyć coś takiego:
App.ActiveDocument.Sketch.setDatum(5,App.Units.Quantity('60.000000 deg'))
Zapisz numer więzu (5). Został on użyty w skrypcie w linii:
App.ActiveDocument.getObjectsByLabel("drivingskt")[0].setDatum(5,App.Units.Quantity(str(angle)+' deg'))

Zmień nazwy korbowodu, tłoka i szkicu odpowiednio na Conrod, Piston i drivingskt. Użyjemy wygodnej metody getObjectsByLabel() Ważne: metoda zwraca listę (jeden lub kilka obiektów). Użyj [0] by wybrać pierwszy obiekt, w skrypcie wygląda to następująco:
App.ActiveDocument.getObjectsByLabel("drivingskt")[0].setDatum(5,App.Units.Quantity(str(angle)+' deg'))
App.ActiveDocument.getObjectsByLabel("Piston")[0].Placement = App.Placement(p1t,App.Rotation(App.Vector(0, 1, 0), 90))
App.ActiveDocument.getObjectsByLabel("Conrod")[0].Placement = App.Placement(p2,App.Rotation(App.Vector(0, 0, 1),conrodangle))

Musisz znać nazwy wierzchołków szkicu. Po prostu najedź kursorem na interesujący wierzchołek i obserwuj pasek stanu. Powinieneś zobaczyć jago nazwę i pozycję.

Pozycja tłoka bazuje na górnym wierzchołku (Vertex1 w moim przykładzie - Vertexes[0], bo lista liczona jest od zera):
        p1 = App.ActiveDocument.getObjectsByLabel("drivingskt")[0].Shape.Vertexes[0].Point
        p1t = p1 + App.Vector(0, 37, 0)

        App.ActiveDocument.getObjectsByLabel("Piston")[0].Placement = App.Placement(p1t,App.Rotation(App.Vector(0, 1, 0), 90))

Pozycja korbowodu bazuje na środkowym wierzchołku (Vertex2, Vertexes[1]):
        p2 = App.ActiveDocument.getObjectsByLabel("drivingskt")[0].Shape.Vertexes[1].Point
        App.ActiveDocument.getObjectsByLabel("Conrod")[0].Placement = App.Placement(p2,App.Rotation(App.Vector(0, 0, 1),conrodangle))


Kąt obrotu korbowodu jest obliczony z wykorzystaniem pozycji wierzchołków (Vertex1 i Vertex2) oraz wektora (0, 1, 0)  (kierunku Y):
        p1 = App.ActiveDocument.getObjectsByLabel("drivingskt")[0].Shape.Vertexes[0].Point
        p2 = App.ActiveDocument.
getObjectsByLabel("drivingskt")[0].Shape.Vertexes[1].Point
        conrodangle = math.degrees(Draft.DraftVecUtils.angle(App.Vector(0, 1, 0),(p1-p2)))
        App.ActiveDocument.getObjectsByLabel("Conrod")[0].Placement = App.Placement(p2,App.Rotation(App.Vector(0, 0, 1),conrodangle))



Jak jest zmieniany kąt w szkicu?
Użyłem regulatora czasowego (timera) z bibliotek Qt. Limit czasu został ustawiony na 50 ms:
self.timer.start(50)

Po 50 ms zostaje wywołane my_update:
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.my_update)

self.an i angle jest kątem obrotu wału odpowiednio w radianach (self.an wynosi 0,01 do 6,28 z krokiem 0,01) i stopniach:

        self.an = self.an + 0.01 if self.an < (2 * math.pi) else 0.0
        angle = math.degrees(self.an)



To wszystko. Baw się dobrze i zaglądaj na forum FreeCAD-a i społeczność Google+!

Inspiracja
FreeCAD Python API

FreeCAD
Version: 0.14.3653 (Git)