-= Kroužek programátora na PS3 =-

[Nil3E]

Kroužek programatora homebrew. - Nil3E

:arrow::arrow:Předmluva (!!Čtěte!!):

Je mi jasné že si řeknete že programování na tuto konzoli musí být zaležitosti hodnou pro "nenormální lidi" zvlášť potom jak uplakaní vyvojaři řikali jak strašně těžko se na architektutu PS3 vyvýjí,

Na jednu stranu je to pravda - I ty nejvíce easy programy (Hello World) mohou na první pohled vypadat nehorazně dlouze a těžce. Opak je však pravdou.

Jde zde jen o to že takový program z 98 procent tvoří kusy kodu které inicalizují různe ovladače, adaptéry a knihovny. Tyhle knihovny i kusy kody jsou pro vás ale většinou připraveny (sconsolePS3, DeadRSX apd..) Všechny tyto hnihovny jsou předem připraveny i s kusy zdrojových kodu, vam stačí si takový kod uložit a pak nakopirovat podle potřeby. Samotné vypsaní textu či zobrazení obrazku je pak otazka pouze jednoho- dvou příkladu. Nenechte se tedy zaleknout komplexnosti dole zobrazených kodu, pokud mate nějaké logické myšlení, a zkušenosti s PC určitě vám to ze začatku pujde těžce ale potom, když budete vedet jak zacházet s takovou konzolí bude to hračka a vy bude programovat na PS3 stejně lehce jako na jakoukoli jinou architektůru co umíte.

Proto to tedy schrnu: Stačí se obeznamit s strukturou, jake knihovny existují a ty si uložit. Pote knihoven využit a nakopirovat je do svých zdrojových kodu ve správné formě a psát C++ program stejně lehce jako cokoliv jiného.

Otázky ZDE --->

Otazky směřujte na muj facebook -> http://www.facebook.com/Nil3E

Přidat do přatel, zeptat se na msg nebo chatu. Nemám moc času ale vynasnažim se.

Tady mi an CF do zprav nepište, to ignoruju uplně

-----------------------------------------------------------------------------------------------------------------------

Poznámka.: Všechn vyvadím na Ubuntu 10.10, PSL1GHT jde taky nastavit na Windowsu přes cygwin a podobné strašnosti, ale pokud se chcete držet tutoriálu nainstalujte ubuntu, nebo použijde virtuální mašinu.

Poznámka.: Musíte umět pracovat v prostředí Linuxu, to tady vyučovat nebudu.

-----------------------------------------------------------------------------------------

:arrow:1 Nastavení PSL1GHT

1.

První věc co po instalaci ubuntu uděláte je nastavit toolchain nastroju (ps3toolchain) pro správne fungování PSL1GHT :) Tak otevři terminál a piš.:

sudo apt-get install autoconf 
sudo apt-get install automake 
sudo apt-get install bison 
sudo apt-get install flex 
sudo apt-get install gcc 
sudo apt-get install make 
sudo apt-get install wget 
sudo apt-get install git 
sudo apt-get install libppl0.10-dev 
sudo apt-get install libcloog-ppl-dev 
sudo apt-get install libelf libelf-dev 
sudo apt-get install libncurses5-dev 
sudo apt-get install texinfo build-essential 
sudo apt-get install libgmp3-dev 
sudo apt-get install python zlib1g-dev 
sudo apt-get install pkg-config 
sudo apt-get install libtool 
sudo apt-get install python-dev 
sudo apt-get install makeinfo 
sudo apt-get install ncurses 
sudo apt-get install patch 
sudo apt-get install subversion 
sudo apt-get install zlib

2.

Vytvořte si adresář kde budete stahovat všechny potřebné balíčky.

(Ja používám "olik" jako svoji přezdívku, vy použijte co chcete)

mkdir -p ~/olik/dev/ps3

3.

Teďka nastavit cesty na stahování balíčku.

(Ja používám "olik" jako svoji přezdívku, vy použijte co chcete)

export PS3DEV=$HOME/dev/ps3 
export PATH=$PATH:$PS3DEV/bin 
export PATH=$PATH:$PS3DEV/host/ppu/bin
export PATH=$PATH:$PS3DEV/host/spu/bin  
export PSL1GHT=$PS3DEV/psl1ght 
export PATH=$PATH:$PSL1GHT/host/bin

4.

Vypněte terminál.

5.

Zase zapneme terminál a diktuju dál ..přepneme do naši složky

cd $PS3DEV

6.

Tak když je všechno nasetupované, mužeme začít s instací samotného toolchainu.

opět pracujeme v terminálu a nastavíme stahovaní s git repa.

git clone git://github.com/ps3dev/ps3toolchain.git 
cd ps3toolchain 
./toochain.sh

7.

Celé stahování a aktualizovaní balíku (+- 1700MB) + nastavení kompilerů a dalších hovadin

bude trvat minimálně 3 hodiny...beze srandy :D (Zaleží an PC a rychlosti připojení)

ale ja si se svou i3 počkal ty 3 hodinky...dejte si čajíček a zakuřte si :)

8.

Nainstalujeme deadRSX at se lepe pracuje s grafickými příkazy, tohle bude trvat jen chviličku.

cd $PS3DEV
git clone git://github.com/Darkhacker/DeadRSX.git 
cd DeadRSX/ 
make 
make install

9.

Restart počítače.

10.

stahněte si deb balíček na http://www.codeblocks.org/

pro lepší zacházení s zrojákama , syntaxema apd.

baličky se instalujou stejně jako normální instalace přes okna, nepotřebujete už terminál.

11.

Vše by mělo být hotovo :)

---------------------------------------------------------------------------------------------------------------------------------------

2. Jak vypadá projekt a jak kompilovat v PSL1GHT

Upozornění:

Při kompilaci je striktně potřeba aby jste dodrželi strom složek do posledního puntíku správně, zajiste jde vše přenasatvit při kompilaci..ale to bych vám nepřal, dostanete se do takového bordelu že nebudete vedet co dál. Striktně doporučuji použivat názvy, seřazení a makefile soubory jaké ja zde popisuji v této kapitole !

Struktura projektu

Struktůra složek pro váš projekt.

Struktury mužou být jak jsem psal výše jiné, vyrazně doporučuji tento druh (Dole přikaldam makefile soubory funkční jen s touto strukturou).

Červeně označené soubory vzniknou až po kompilaci.

Tlustý text jsou složky

Zakřivený text jsou soubory

[size=4]
[/size]
[list]
[*][size=4]<složka vašeho projektu>
[list]
[*]build
[list]
[*]pkg
[/list]

[*]data
[*]source
[list]
[*]main.c
[/list]

[*]include
[*]makefile
[*][color=red](soubor).elf[/color]
[*][color=red](soubor).self[/color]
[*][color=red](soubor.pkg[/color]
[/list]
[/size]
[/list]

Mala ukázka, jak by to asi mělo vypadat už se souborama.:

[list]
[*]Ondrova Hra
[list]
[*]build
[list]
[*]pkg
[list]
[*]ICON0.png
[*]PARAM.sfo
[/list]

[/list]

[*]data
[list]
[*]auto1.png
[*]auto2.png
[*]autodraha.png
[*]instrukce.txt
[*]zvuk.ac3
[*]hudba.mp3
[/list]

[*]source
[list]
[*]main.c
[*]hra.c
[*]menu.c
[*]efekty.c
[/list]

[*]include
[*]makefile
[*]ondrovahra.elf
[*]ondrovahra.self
[*]ondrovahra_balik.pkg
[/list]

[/list]

Vysvětlení jednotlivých souborů:

• makefile - Předefinovaný "textový" soubor který určuje compileru jak správně nabuildovat balíček, ke každému projektu ho musíte přiložit, dole ještě popiši jak takový soubory vytvořit
  

Nasledující soubory vzniknou až po spuštění přikazu (make/makepkg), tedy až po nakompilování zdrojového kodu:

• (soubor).elf - Tento soubor vznikne až po nakompilování programu, jedna se o NEPODEPSANY Linkovaný a spouštěcí format použivaný u všech Playstationu (PSone/PS2/PS3/PSP)
  
• (soubor).self - Stejný soibor jako *.ELF , tentokrát však už jde o podepsaný/certifikovaný "SIGNED" ELF.
  
• (sobor).pkg . Balíček který znamé jako instalační, který vznikne po nakompilovaní programu. Obsahuje zabalený ELF, SELF soubor a taky zbytek potřebných souboru, které náš program bude použivat.
  

Vysvětlení jednotlivých složek projektu:

• build - Do této složky se builduje všem známy "EBOOT" soubor a PARAm soubor pro balíčky, tyto soubory mužete sami konfigurovat, aby vaše aplikace nějak vizuálně vypadala...Ikonka, pozadí a zvuk v XMB, nastavení názvu, verze, rodičovksé ochrany, trial serepetiček a dalších funkcí které pkg balíky Playstationu nabízí.
  
• data - Do teto složky přiložujeme další soubory, které chceme přibalit do anšeho konečného balíku (Všechny zvuky, obrázky a veškeré další potřebné soubory, které budeme využivat, nebo jen chceme přibalit do pkg balíčku)
  
• source - Zde hazíte veškeré *.c soubory, tedy zdrojové soubory "zdrojáky" které sami píšeme. Jako indexní soibor, PSL1GHT použivá "main.c"
  

Složky mužete mít vlastně jak chcete, ale doporučuji vam tuto skladbu..jinak se budete muset vrtat v makefile souborech a vše to překopavat, ja jsem vše nastavil tak jak to mate nahoře zíměnné

Makefile soubory

jak sem psal výše v kořenové složce je Potřebný mít soubor makefile, který dava instrukce kompileru, zde vam vložím ukazkový vnitřek souboru i s popiskami, dole je link ke stažení, mužete využit muj a vyvarovat se psání vlastního.

[color=lime]//Hlavička dokumentu[/color]
.SUFFIXES:
ifeq ($(strip $(PSL1GHT)),)
$(error "PSL1GHT must be set in the environment.") [color=lime]//Tento text v uvozovkách bude vypsan, když máte špatně nakonfigurovaný psl1ght[/color]
endif

include $(PSL1GHT)/Makefile.base

TARGET        :=    $(notdir $(CURDIR))[color=lime] //Nastavení cesty ke složce obsahující potřebné soubory, ponechte "$(notdir $(CURDIR))" - toto značí že využívate složku ve které pravě makefile je[/color]
BUILD        :=    build  [color=lime]//Nastavení jména složky pro build soubory[/color]
SOURCE        :=    source  [color=lime]//nastavení ke složce, která obsahuje zdrojové kody (main.c)[/color]
INCLUDE        :=    include
DATA        :=    data [color=lime]// nastavení cestě ke složce s daty[/color]
LIBS        :=    -lgcm_sys -lreality -lsysutil -lio -lpngdec -lsysmodule [color=lime]//nastavení využivaných knihoven, popišuje je ještě niže, oddělujeme pomlčkou[/color]
TITLE        :=    test - PSL1GHT [color=lime]//Nastavení jména balíku, jak bude indentifikován v XMB[/color]
APPID        :=    NILE00001 [color=lime]//Nastavení indetifikačního čisla, mužete použit ID nějaké hry jako "stealth" před banem.[/color]
CONTENTID    :=    UP0001-$(APPID)_00-0000000000000000 [color=lime]//Nasledující ID neni potřeba nějak měnit[/color]
CFLAGS        += -g -O2 -Wall --std=gnu99
CXXFLAGS    += -g -O2 -Wall

ifneq ($(BUILD),$(notdir $(CURDIR)))

[color=lime]//nastavení složek na export, zde je vše nastaveno tak jak potřebujete[/color]
export OUTPUT    :=    $(CURDIR)/$(TARGET)
export VPATH    :=    $(foreach dir,$(SOURCE),$(CURDIR)/$(dir)) \
                   $(foreach dir,$(DATA),$(CURDIR)/$(dir))
export BUILDDIR    :=    $(CURDIR)/$(BUILD)
export DEPSDIR    :=    $(BUILDDIR)

[color=lime]//nastavení cest k souborum "C,S,BIN"...pokud dodržujete popisy mych složek, zde je taky vše nastaveno, pokud mate zdrojové soubory uložene jinak, budete opět muset upravovat. A to vam nepřeji =P.[/color]
CFILES        := $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.c)))
CXXFILES    := $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES        := $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.S)))
BINFILES    := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.bin)))

[color=lime]//Nastavení exportu, nemusíte se v tom vrtat, vše je přednastaveno jak je potřeba[/color]
export OFILES    :=    $(CFILES:.c=.o) \
                   $(CXXFILES:.cpp=.o) \
                   $(SFILES:.S=.o) \
                   $(BINFILES:.bin=.bin.o)

export BINFILES    :=    $(BINFILES:.bin=.bin.h)

export INCLUDES    :=    $(foreach dir,$(INCLUDE),-I$(CURDIR)/$(dir)) \
                   -I$(CURDIR)/$(BUILD)

.PHONY: $(BUILD) clean pkg run

$(BUILD):
   @[ -d $@ ] || mkdir -p $@
   @make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile

clean:
   @echo Clean...
   @rm -rf $(BUILD) $(OUTPUT).elf $(OUTPUT).self $(OUTPUT).a $(OUTPUT).pkg

[color=lime]// Samotné nastavení cest na vytvoření PKG instalačního balíku při použití makepkg příkazu, zde ja opět vše nastaveno pokud dodržujete mé instrukce na složky[/color]
pkg: $(BUILD)
   @echo Creating PKG...
   @mkdir -p $(BUILD)/pkg
   @mkdir -p $(BUILD)/pkg/USRDIR
   @cp $(ICON0) $(BUILD)/pkg/
   @$(FSELF) -n $(BUILD)/$(TARGET).elf $(BUILD)/pkg/USRDIR/EBOOT.BIN
   @$(SFO) --title "$(TITLE)" --appid "$(APPID)" -f $(SFOXML) $(BUILD)/pkg/PARAM.SFO
   @$(PKG) --contentid $(CONTENTID) $(BUILD)/pkg/ $(OUTPUT).pkg

run: $(BUILD)
   @$(PS3LOADAPP) $(OUTPUT).self

else

[color=lime]//Nastavení cest k ELF, SELF souborum pro náš balíček..opět je zde vše přednastaveno[/color]
DEPENDS    := $(OFILES:.o=.d)

$(OUTPUT).self: $(OUTPUT).elf
$(OUTPUT).elf: $(OFILES)
$(OFILES): $(BINFILES)

-include $(DEPENDS)

endif

Stahněte si makefile soubor bez poznámek pro váš projekt ZDE:

http://www.edisk.cz/stahni/76357/makefile_psl1ght_oli.rar_2.08KB.html

Kompilujem

Pomocí terminálu, přepnem do složky projektu. (Zajiste pužijte vlastní cestu)

cd psl1ght/projekty/ondrovahra/

Až přepnete do složky, použijem přikaz make pro nabuildování ELF a SELF soiboru.

make

po dokončení kompilace, použijem přikaz make pkg, který vytvoří ve složce projektu <vaš projekt>.pkg, tento baliček pak mužeme nainstalovat v PS3.

make pkg

Převádíme 3.xx homebrew na "3.55 Homebrew"

Pro převod musíte mít připraveny ELF, SELF soubory !

Otevřít terminál a psát, zajisté nezapomente použít opět vlastní cesty k balíkům.

METODA 1:

cd /tmp/update_package.$$

pkg.py -x old.3.41.pkg

unself UNIQDIR/USRDIR/EBOOT.BIN xxxxxxx.elf

make_self_npdrm xxxxxxxxx.elf EBOOT.BIN UNIQDIR

mv EBOOT.BIN UNIQDIR/USRDIR/

pkg.py --contentid UNIQDIR /tmp/update_package.$$/UNIQDIR/ new.3.55.pkg

package_finalize new.3.55.pkg

METODA2:

#Wutangrza's lazy man's scriptStačí stáhnout tento skript a spustit v terminálu, vším vás to provede :)

http://www.edisk.cz/stahni/05675/script.zip_1.94KB.html

Publictools

Nástroje, které podepisují SELF a PKG soubory pro použití na všech známých Custom Firmwarech 3.55.

Geohotovy nástroje:

Užitečné geohotovy nástroje pro Windows i Linux pro praci s pkg balíčkama.

Balík obsahující všechny nástroje - Pro Win32 i Linux

http://www.megaupload.com/?d=GX70P7OS

Stačí váš pkg balíček spustit přes program signpkg.exe

make-self - Vytvoří podepsaný elf soubor, potřebný pro instalaci na Geohotově Vustom Firmwaru,

package-finalize - Zabalí elf/self do balíku který následně taktež podepíše pro Geohotuv CFW.

Fail0verflow nástroje:

Ke stažení a další informace na:

http://ps3.dashhacks.com/2011/01/12/all-of-fail0verflows-ps3-tools-released/

Dostupné pouze pro Linux

makepkg - Vytvaří podepsaný CFW balíček (Geohot alternativa)

makeself - vytvaří podepsané SELF soubory (Geohot alternativa)

unpkg - Rozbaluje již zabalené pkg soubory

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

5. První TEXT + Sconsole Knihovna

Playstation pracuje v "konzolovém" režimu, když neni spuštěn grafický RSX ovladač.

Byla vytvořena knhovna SconsolePS3 , ktera zajištuje vypis textu na obrazovku bez jakéhokoliv spuštění grafické knihovny (DeadRSX). Program se bude na PS3 tedy chovat stejně jako program v příkazové řadce či Terminálu.

Sconsolu si mužete s PKG i zdrojovým kodem stahnout ZDE:

http://www.edisk.cz/stahni/80104/sconsoleDemo.zip_730.37KB.html

Vysvtěluji dále...

Struktura složek sconsole:

sconsole

--include

----sconcole.h <----- Sconsole knihovna

----console_fonts.h <----- Sconsole knihovna

--source

----main.c

----sconcole.c <----- Sconsole knihovna

--MAKEFILE

1.

Udělejme si nový main.c. A pišme (pokud mate main.c z sconsole archivu pozorně poslouchejte jak časti zdojáku fungují.

#include < psl1ght/lv2.h >  
#include < stdio.h > 
#include < malloc.h > 
#include < string.h > 
#include < assert.h > 
#include < unistd.h >  
#include < sysutil/video.h >  
#include < rsx/gcm.h > 
#include < rsx/reality.h > 
#include < io/pad.h >  

#include "sconsole.h"<------ Toto je knihovna sconsole, kterou načitame aby jsme mohli použit přikazy samotné sconsole

2.

Jako u každého programovacího jazyka za hlavičku definujeme proměnné programu:

typedef struct {
   int height;
   int width;
   uint32_t *ptr;
   // Internal stuff
   uint32_t offset;
} buffer;

gcmContextData *context;
VideoResolution res; [color=lime]<---- Nastavení rozlišení konzole, nedoporučuji to nějak měnit, tento přikaz automaticky přepina podle povolených video režímu v PS3[/color]
int currentBuffer = 0; 
buffer *buffers[2]; [color=lime]<---- Nastavení bufferu, u textoveho režimu přikaz nijak neměnime, takže zapamatovat[/color]

//example string with \n
char* longString = " Ahoj, tohle je Nil3E se svým tutoriálem."; [color=lime]<-- v uvozovkách amem string který bude konzole vypisovat.[/color]

3.

Nasledující kod je klasický C++ styl, takže pokud umíte C++, už nikdy nebudete mít problém pokračuje se téměř klasicky.

Pro ostatní zatím vysvětlovat nebudu, zdrojak nechte tak jak je, popřipadě nakopirujte si do svého main.c a nechte být.

Ve skratce po začatečniky -> Klasický Flip který zajištuje správne zobrazení textu a nastavení paměti a video bufferu (vyrovnávání).

Jeden z kodu, který se opravdu učit pořádně nemusíte, stačí když si ho někam uložite pak nakopirujete do svého a lehce poupravite.

void waitFlip() { // Block the PPU thread untill the previous flip operation has finished.
   while(gcmGetFlipStatus() != 0) 
       usleep(200);
   gcmResetFlipStatus();
}

void flip(s32 buffer)
{
   assert(gcmSetFlip(context, buffer) == 0);
   realityFlushBuffer(context);
   gcmSetWaitFlip(context);
}

void makeBuffer(int id, int size)
{
   buffer *buf = malloc(sizeof(buffer));
   buf->ptr = rsxMemAlign(16, size);
   assert(buf->ptr != NULL);

   assert(realityAddressToOffset(buf->ptr, &buf->offset) == 0);
   assert(gcmSetDisplayBuffer(id, buf->offset, res.width * 4, res.width, res.height) == 0);

   buf->width = res.width;
   buf->height = res.height;
   buffers[id] = buf;
}

void init_screen()
{
   void *host_addr = memalign(1024*1024, 1024*1024);
   assert(host_addr != NULL);

   context = realityInit(0x10000, 1024*1024, host_addr); 
   assert(context != NULL);

   VideoState state;
   assert(videoGetState(0, 0, &state) == 0);
   assert(state.state == 0);

   assert(videoGetResolution(state.displayMode.resolution, &res) == 0);

   VideoConfiguration vconfig;
   memset(&vconfig, 0, sizeof(VideoConfiguration));
   vconfig.resolution = state.displayMode.resolution;
   vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
   vconfig.pitch = res.width * 4;

   assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
   assert(videoGetState(0, 0, &state) == 0); 

   s32 buffer_size = 4 * res.width * res.height;

   gcmSetFlipMode(GCM_FLIP_VSYNC);
   makeBuffer(0, buffer_size);
   makeBuffer(1, buffer_size);

   gcmResetFlipStatus();
   flip(1);
}

4.

Zase po hromadě inicializace hotového satanského pekla, které PS3 předsatvuje jsme se dostali (huráá) k vypisování textu a nastavování sconsole knihovny (barvy, font, tlačítka apd..) !.

s32 main(s32 argc, const char* argv[])
{
   PadInfo padinfo;
   PadData paddata;
   int i,j;

   init_screen();
   ioPadInit(7);
   /* [color=lime]
//Zde načítáme parametry konzole !! nezapomente že vše mužete nastavit v kongigurační časti v sconsole knihovně, která se nachází ve složce include ! :)[/color][color=lime]
// FONT_COLOR_BLACK nam označuje že barva textu je nadefinována na černou[/color]

       Init the console: arguments (background color, font color, framebuffer, screen width, screen height)
       sconsoleInit(int bgColor, int fgColor, int screenWidth, int screenHeight)
   */
   sconsoleInit(FONT_COLOR_NONE, FONT_COLOR_BLACK, res.width, res.height);
   char ts[1000];


[color=lime]// Konečně mame nějaké to kliknutí (BTN_CROSS) označuje že se tato procedura uda po stiknutí CROSS (křížku na připojenem ovladači)
[/color]
   while(1)
   {
       ioPadGetInfo(&padinfo);
       for(i=0; i<MAX_PADS; i++)
       {
           if(padinfo.status[i])
           {
               ioPadGetData(i, &paddata);
               if(paddata.BTN_CROSS)
                   return 0;
           }        
   }

   waitFlip();

   [color=lime]//Vykreslení pozadí ( FONT_COLOR_WHITE) naše pozadí bude bíle
  // mužete použit  (FONT_COLOR_RED) napřikald pro červenou barvu (počitam s tim že barvy anglicky umíte)[/color]
  for(i = 0; i < res.height; i++)
   {
       for(j = 0; j < res.width; j++)
           buffers[currentBuffer]->ptr[i* res.width + j] = FONT_COLOR_WHITE;
   }

   [color=lime]//Vypisujeme FUNKCE: Tyto funkce (res.width, res.height) vypišou aktuální rozlišení[/color]
   sprintf(ts, "Rozlišeni vaši obrazovky: %dx%d", res.width, res.height);
   print(540, 160, ts, buffers[currentBuffer]->ptr);

   print(400, 64, "Ahojte všichni", buffers[currentBuffer]->ptr); [color=lime]//Vypis textu v uvozovkách na obrazovku[/color]
   print(400, 80, "By Olik (Nil3E)", buffers[currentBuffer]->ptr); [color=lime]//Vypis textu v uvozovkách na obrazovku[/color]
   print(580, 580, "Stikni křižek a vyponi mě!", buffers[currentBuffer]->ptr); [color=lime]//Vypis textu v uvozovkách na obrazovku[/color]
   print(10, 500, longString,  buffers[currentBuffer]->ptr); [color=lime]// Výpis dřive určené proměné (viz promene tohoto tutoriálu)[/color]

   flip(currentBuffer);
   currentBuffer = !currentBuffer;
   }

   return 0;
}

5.

Vše je hotovo, mužeme kompilovat "make pkg" jak jsem vas to výše učil.

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

4. Inicializujeme deadRSX knihovnu a Zobrazujeme PNG obrázek. (Hello World )

možna už vidíte jak dlouhá taková blbost je, nenechte se vystrašit.

Tento Tutoriál popisuje inicializaci grafického rozhraní pomoci DeadRSX, což zajišťuje přepnutí z textového režimu do Grafického. Jedná se o zaležitost, kterou se nemusíte učit, stačí kody na inicializaci zkopirovat a pak využivat.

Zobrazení PNG je pak otázka jednoho hloupého příkazu.

Popis:

Hello World obrázek zobrazení na obrazovce

Struktura mé složky:

obrazektest

-release

--USRDIR

---helloworld.png

-source

--main.c

-MAKEFILE

1.

Vytvořte si počateční soubor ve složce Source jak sjem popisoval výše (main.c). Tento pak otevřete třeba v code::blocks nebo v klasickém textovém editoru (Však dopořučuju code:blocks) ten podtruhue a obarvuje syntaxe pro přehlednost.

Začneme tedy hlavičkou souboru:

#include < stdio.h > 
#include < malloc.h > 
#include < string.h > 
#include < assert.h > 
#include < unistd.h > 
#include < math.h > 
#include < rsx/commands.h > 
#include < rsx/nv40.h > 
#include < rsx/reality.h > 
#include < io/pad.h > 
#include < sysmodule/sysmodule.h > 
#include < sysutil/events.h >  
#include < deadrsx/deadrsx.h > //include deadrsx 
#include < deadrsx/texture.h > 
#include < deadrsx/nv_shaders.h >

Vystětlení:

před tím než začneme psát program v halvičce musí být obsažené základní cečkové knihovny, které budem použivat, knihovny jednotlive ještě popiši.

---

2.

po dokončení hlavičky, je potřeba jako v každém prog. jazyce definovat proměné.

int helloworld_x=500,helloworld_y=500; [color=lime]//lokace obrázku v souřadnicích osy (x,y)[/color]
int currentBuffer = 0; [color=lime]//Grafický buffer si vysvtělíme později[/color]
PadInfo padinfo; 
PadData paddata; 
u32 *tx_mem,helloworld_offset; [color=lime]//offset našeho obrázku, tedy co z obrázku chceme použit = chceme celý[/color]
PngDatas helloworld_image;

---

3.

DeadRSX

DeadRSX je open-source grafický ovladač na tu zhovadilou nvidia graficky čip v PS3, jsou to komplexní hovadiny..doparočuji se to neučit jen nakopirovat pod proměné nasledující kus kodu pro incicializaci ovladače.

Takže nad nasledujcím kodem si orpavdu nelamte hlavu, použivejte ho pod proměné na každý váš program, někam si ho uložte..měl by poté bez problému inicializovat grafiku v PS3.

void drawFrame(int buffer, long frame) { realityViewportTranslate(context, 0.0, 0.0, 0.0, 0.0); 
realityViewportScale(context, 1.0, 1.0, 1.0, 0.0); 
//deadrsx_scale();  // scales screen to 847x511 - deadrsx library 
realityZControl(context, 0, 1, 1); // disable viewport culling reality
BlendFunc(context, NV30_3D_BLEND_FUNC_SRC_RGB_SRC_ALPHA | NV30_3D_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA, NV30_3D_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_ALPHA | NV30_3D_BLEND_FUNC_DST_ALPHA_ZERO); 
realityBlendEquation(context, NV40_3D_BLEND_EQUATION_RGB_FUNC_ADD | NV40_3D_BLEND_EQUATION_ALPHA_FUNC_ADD); 
realityBlendEnable(context, 1); 
realityViewport(context, res.width, res.height); 
setupRenderTarget(buffer); 
realitySetClearDepthValue(context, 0xffff); 
ealityClearBuffers(context, REALITY_CLEAR_BUFFERS_COLOR_R | REALITY_CLEAR_BUFFERS_COLOR_G | REALITY_CLEAR_BUFFERS_COLOR_B | NV30_3D_CLEAR_BUFFERS_COLOR_A | NV30_3D_CLEAR_BUFFERS_STENCIL | REALITY_CLEAR_BUFFERS_DEPTH); 
realityLoadVertexProgram_old(context, &nv40_vp); 
realityLoadFragmentProgram_old(context, &nv30_fp); 
deadrsx_sprite(helloworld_offset, helloworld_x, helloworld_y, 500, 500, 496, 330, 0, 0, 1, 1); }

---

4.

a za deadrsx skript jen dopišeme poslední linku, která vykreslí obrázek na danných souřadnicích.

Toto je jednina linka deadrsx skriptu kterou budete muset podle programu upravovat.

Proto se vynasnažte pochopit v jakém pořadí jsou zde instrukce.

deadrsx_sprite(helloworld_offset, helloworld_x, helloworld_y, 500, 500, 496, 330, 0, 0, 1, 1);

Vysvětlení:

helloworld_offset - Offest obrázku, který jsme si určili v porměných, toto pouze odkazuje na proměnou

helloworld_x, helloworld_y - Opět odkazujeme na proměnou, x,y - tedy kde bude obrázek vykreslen.

Místo proměn mužeme zajisté použit přímo určené čísla, doporučuji však použivat proměné pro jednoduší manipulaci třeba pomocí tlačítek a ostatních dalších "vylepšení"

---

5.

Další čast programu, kterou ještě není potřeba poznávat blíže.

Nasledující kod obsahuje:

Eventhandler - Který umožnuje ukončit program, bez toho aniž by jsme museli vytahovat konzoli od napájení, tedy zajišťuje přistup do ingame XMB a taktež zajistí aby nedošlo k zamrznutí konzole bez vypínání

Cleanup - čistí program a RAM konzole, zajišťuje plynulý chod apliakce.

obojí nechte tak jak je :) Seznamíme se s handlerem později :) Ale ve 98 procentech programu vam bude stačit tento ředepsaný eventhandler pro dobrý chod aplikace.

static void eventHandle(u64 status, u64 param, void * userdata) {
   (void)param;
   (void)userdata;
   if(status == EVENT_REQUEST_EXITAPP){
   exit(0);//exit app
   }else if(status == EVENT_MENU_OPEN){
   //openxmb
   }else if(status == EVENT_MENU_CLOSE) {
       //closexmb
   }else{
   printf("Unhandled event: %08llX\n", (unsigned long long int)status);
   }
}
void appCleanup(){
   sysUnregisterCallback(EVENT_SLOT0);
}

---

6.

Hurá. Konečně jsme se po tom nekonečněm inicializování Grafického rozhraní dostali k samotnému načítaní png obrázku. V kodu si povšimněte že je potřeba definovat cestu k obrázu, podívejte se na strukturu mých složek na začátku tutoriálu. Pokud jste tedy něco měnili, musíte se blíže kouknout na tenhle kod.

void loading() {
  deadrsx_loadfile("/dev_hdd0/game/ondrovahra/USRDIR/helloworld.png", helloworld_image, &helloworld_offset);

Vysvětlení:

deadrsx_loadfile - Jednoduchý přikaz po inicializaci DeadRSX na načtení souboru do paměti a vykreslení ho pomoci knihovny libpng (kterou jsme načetli v hlavičce programu) na obrazovku.

----

7.

Loop programu zajišťuje aby jsme si vubec obrazku všimli, kdyby nebylo loopu obrazek by se tak rychle zobrazil a zmizel že by jsme to v té rychlosti ani nevšimli.

Loop (obrat programu) zajišťuje aby se instrukce opakovala a my byli schopní vubec funkci postřehnout /v našem připadě zobrazeni PNG obrázku/

s32 main(s32 argc, const char* argv[])
{

   atexit(appCleanup);
   deadrsx_init();
   ioPadInit(7);
   sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);

   u32 *frag_mem = rsxMemAlign(256, 256);
   printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
   realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);

       loading(); // where all the loading done xD

   long frame = 0; 

   while(1){
       waitFlip(); 
       drawFrame(currentBuffer, frame++); 
       flip(currentBuffer); 
       currentBuffer = !currentBuffer;
       sysCheckCallback();

   }

   return 0;
}

-----

8.

Hotovo, mužete bulidovat "make pkg" jak jsem vás to učil a vychutnat si rpvní program na PS3 :)

Enjoy :)

ZDE SI MUŽETE STAHNOUT ZDROJÁK I PODEPSANÝ PKG SOUBOR, TAKŽE NEMUSÍTE ANI PSÁT STAČÍ KDYŽ SI PRÁCI PROHLEDNETE :)

+-1MB:

http://www.edisk.cz/stahni/41405/tutorial1_obrazekpng_nil3e.zip_1.04MB.html

-----------------------------------------------------------------------------------------------------------------

-------------------------------------------------------

[Panther]

Parada si fakt borec!

[PEchi]

oprášim znalosti ze školy, instaluju virtual mašinu a budeme si hrát xD

[Samot2]

Po státnicích taky něco zkusím :)) Dobrá práce!

[Nil3E]

Update....

[Samot2]

Teď mě napadlo, že by si s tím mohl vlítnout i na abclinuxu.cz a tam to publikovat, mohlo by to mít i úspěch :)

[Jakcz]

co kdyby jste někdo udělal něco na PSN aby šlo a publikovaly jen tady na tomhle forum tak aby se o tom sony nedozvěděla a neopravila