Po obecném úvodu v minulém díle si dnes, jak jsme si posledně ostatně slíbili, vytvoříme náš
vůbec první funkční program v Pythonu. A jak jsem již v předchozím článku naznačil, půjde o
jednoduchý čtvercový mesh objekt.
Nejprve si tedy ukážeme celý programový kód a následně jej v důležitých bodech
rozebereme.
Programový kód
Nebudu vás dlouho napínat, celý programový kód vypadá následovně:
#########################################################
# #
# Jednoduchy skript na tvorbu ctvercove plochy (mesh) #
# Autor: Pavel Pokorny, 1. 8. 2005 #
# go.paja@centrum.cz #
# #
#########################################################
import Blender # nacteni modulu Blenderu
from Blender import NMesh # budeme pracovat s Mesh objekty
me=NMesh.New() # vytvorime si novy mesh objekt
#me=NMesh.GetRaw() # totez co predchozi pripad
v=NMesh.Vert(1.0,0.0,0.0) # a pridame do nej 4 nove vertexy
me.verts.append(v)
v=NMesh.Vert(1.0,1.0,0.0)
me.verts.append(v)
v=NMesh.Vert(0.0,1.0,0.0)
me.verts.append(v)
v=NMesh.Vert(0.0,0.0,0.0)
me.verts.append(v)
f=NMesh.Face() # vytvorime si novy face
f.v.append(me.verts[0]) # pridelime mu 4 vertexy
f.v.append(me.verts[1])
f.v.append(me.verts[2])
f.v.append(me.verts[3])
me.faces.append(f)
NMesh.PutRaw(me, "Plane") # pridani noveho objektu do sceny
Blender.Redraw() # prekresleni sceny
Pojďme si nejdříve popsat program jako celek. Posloupnost jednotlivých příkazů odpovídá
tomu, jak bychom očekávali. Nejprve tedy vytvoříme nový objekt typu mesh, do tohoto meshe
vložíme čtyři vertexy a mezi těmito vertexy vytvoříme jednu plochu. V posledním kroku daný
mesh přidáme do scény.
Taková je tedy základní koncepce. Nyní si už podrobně popíšeme jednotlivé části
programového kódu. Postupovat budeme od začátku programu. Dříve, než se ale dostaneme k
prvnímu příkazu, zmíním se o komentářích. Už jste z uvedeného programu asi pochopili, že
komentáři předchází znak #, a platnost každého takového komentáře je až do
konce příslušného řádku. Samozřejmě je vhodné do programu komentáře umísťovat, jednak na
začátek programu, kde by měl být popisek o jaký program jde, kdo a kdy ho vytvořil, verze,
apod. a dále k určitým blokům nebo příkazům pro bližší popis, co daná část dělá. Sice se to
může zdát zbytečné, ale pokud se někdy později k danému programu vrátíte, snadněji se v něm
budete orientovat.
Když tedy pomineme komentáře, prvním příkazem je import Blender. Příkaz
import je obdobou příkazu v C jazyku #include. Jinými slovy, na
začátku každého programu si potřebujeme vždy vložit knihovny (moduly), které budeme
používat. Uvedeným příkazem v našem programu tedy vkládáme modul Blenderu (ten budeme
vkládat v každém programu) a tím si zajistíme dostupnost objektů a metod, které v sobě
obsahuje. Později budeme vkládat ještě i jiné moduly. Tím chci naznačit, že podle toho, jaké
moduly vkládáte, snadno zjistíte, co musíte mít nainstalované. Pokud vkládáme pouze modul
Blenderu, nemusíme mít nainstalovaný Python jako takový, vystačíme s tím, co nám Blender
nabízí (a že toho není málo).
Dalším příkazem je from Blender import NMesh. Modul Blender, který jsme si
již do našeho programu vložili, obsahuje celou řadu submodulů a my bychom měli kompilátoru
říci, jaké budeme používat. Submoduly jsou například Camera, Lamp, Image, World,
Material, Texture, Object... Seznam všech submodulů včetně referenčních popisů jejich
atributů a metod naleznete v dokumentaci k Pythonu na domovských stránkách Blenderu zde
(tento odkaz jsem uvedl již v předchozím článku). Dneska pouze vytváříme objekty typu Mesh,
proto načítáme pouze modul NMesh.
Možná se ptáte, proč do programu musíme vložit modul Blenderu a pak jeho submodul(y).
Odpvěď zní: nemusíme. Příkaz from Blender import NMesh v programu skutečně být
nemusí. Pokud ho ale neuvedeme, budeme muset upravit všechny další příkazy, které se týkají
submodulu NMesh. Takže příkaz v=NMesh.Vert(1.0,0.0,0.0) bychom
museli zapsat jako v=Blender.NMesh.Vert(1.0,0.0,0.0). Jinými slovy, všude, kde
vidíte slovíčko NMesh, bychom před nějmuseli připsat Blender., aby
kompilátor věděl, že daný příkaz je součástí tohoto modulu. Je zcela na vás, který ze
způsobu zápisu budete používat. Můj názor je, že je vhodné kombinovat oboje. První způsob
vám šetří čas a snižuje velikost souboru, ten druhý je zase přehlednější, jelikož okamžitě
víte, jakého modulu (či submodulu) je příkaz součástí.
Pojďme ale v našem programu dál. Po importování následuje příkaz
me=NMesh.New(). Za ním je v komentáři ještě jeden -
me=NMesh.GetRaw(). Oba dělají prakticky to samé, totiž vytvářejí nový objekt
typu mesh. Abych byl přesnější - obě metody mohou mít jeden parametr (viz. dokumentace),
kterým je jméno mesh objektu. Metoda New vždy vytváří nový prázdný mesh objekt
a metoda GetRaw získá data meshe jehož jméno je uvedeno jako parametr této
metody. Pokud žádné parametry nejsou, vytvoří se také nový prázdný mesh objekt a ten
přiřadíme identifikátoru me. Jméno mesh objektu zatím zadávat nebudeme, to
uděláme později.
V dalším kroku přiřazujeme mesh objektu čtyři vertexy. Práce s každým z nich je rozložena
do dvou příkazů. Prvním z nich je přiřazení nového vertexu do identifikátoru (u prvního
vertexu je to příkaz v=NMesh.Vert(1.0,0.0,0.0)). Metoda Vert u
submodulu NMesh obsahuje tři parametry a jak už asi tušíte, jsou to globální
souřadnice x, y a z. Ve druhém kroku příslušný identifikátor reprezentující vertex přidáme
do mesh objektu příkazem me.verts.append(v). Není na tom nic složitého - takto
si můžete do mesh objektu vložit vertexů kolik chcete. Chtěl bych ale ještě upozornit, že
záleží na tom, v jakém pořadí vertexy do mesh objektu vkládáte. To pořádí by mělo být v
souladu s vytvářenou plochou, která bude dalším krokem. Nezáleží na tom, který z vertexů
vložíte do mesh objektu jako první, ale obecně platí, že by měly být vertexy vkládány v
pořadí, jak jdou za sebou. To znamená buď po směru hodinových ručiček nebo proti tomuto
směru. Způsob, který zvolíte ovlivňuje směr normály později vytvořené plochy. Schválně to
vyzkoušejte. A nebojte se i experimentovat s pořadím vertexů. Zkuste je nezadat podle
pravidla, které jsem teď popsal. Tímto způsobem nejlépe pochopíte, jak to v Blenderu
funguje.
V dalším kroku si vytvoříme novou plochu (face). To provedem příkazem
f=NMesh.Face(). Za ním následuje volání metody f.v.append
tolikrát, z kolika vertexů se daný face musí skládat (v našem příadě jsou to čtyři).
Všimněte si, že parametrem této funkce jsou příslušné vertexy v meshi, které jsme mu vložili
v předchozím kroku a tyto vertexy jsou ukloženy v poli (toto využijeme později). Poté, co
dané ploše reprezentované identifikátorem f vertexy přidáme, tuto plochu přiřadíme námi
vytvořenému mesh objektu. To dělá příkaz me.faces.append(f).
Předposledním příkazem NMesh.PutRaw(me, " Plane") příslušný mesh vložíme do
scény. Prvním parametrem této metody je identifikátor námi vytvořeného mesh objektu a druhým
je jeho jméno (textový řetězec). Pokud bychom takovýto program spustili, v některých
případech bychom na obrazovce nic nemuseli vidět. Je to z toho důvodu, že je často potřeba
celou scénu překreslit. Toto nám právě dělá poslední uvedný příkaz
Blender.Redraw().
Úkol
Ta, to je pro dnešek vše. Snad to bylo aspoň trochu srozumitelné. Nyní ještě dnešní úkol.
Ve výše uvedeném příkladu jsme si vytvořili jednoduchý čtvercový mesh. Zkuste na základě
uvedených informací vytvořit krychli, tj. ve skutečnosti bude 8 vertexů a 6 faců. Pokud jste
porozumněli výše uvedenému popisu, neměl by to být problém. Pokud si přesto nevíte rady,
níže je ke stažení zdrojový kód.
autor:Pavel Pokorný
Univerzita Tomáše Bati ve Zlíně
Fakulta technologická
