30.11.2009 von AnMaBaGiMa.

Nachdem der Grundstein gelegt ist, wird die Homebrew-Basisklasse nun benutzt um ein Feuer auf den PSP-Bildschirm zu zaubern. Wie der Feueralgorythmus aussieht und wie das Feuer dann auch noch dargestellt wird, ist im Detail auf folgender heißen Seite beschrieben.

Um die dort vorgestellte Klasse in Eurem Homebrew nutzen zu können muss die main.cpp wie folgt angepasst werden:

/*
* main.cpp
*
* In dieser kleinen Homebrew, lassen wir die PSP “brennen”
*/
#include “PspFeuer.h”
extern “C”{
#include <pspkernel.h>
}
PSP_MODULE_INFO(”PSP Feuer”, 0, 1, 1);
PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);
int main(int argc, char* argv[])
{
//Aplikation instantiiren
ClPspFeuer* myHomebrew = ClPspFeuer::getInstance();
if (myHomebrew->init()){
myHomebrew->run();
}
myHomebrew->exit();
//Homwbrew verlassen
sceKernelExitGame();
return 0;
}

Um das neue Homebrew nun erstellen zu können, muss das Makefile noch um die neue Datei erweitert werden in der unsere Applikation implementiert ist:

OBJS = main.o PspFeuer.o Homebrew.o ../common/callbacks.o

Wenn alles glatt gelaufen ist, dann sieht es auf der PSP so aus:

Geschrieben in Erste Schritte | Drucken | Keine Kommentare »

25.11.2009 von AnMaBaGiMa.

Bevor ich nun aus meinem kleinen “Hallo Welt!” Programm eine kleine Anwendung stricke, ist es sinnvoll sich ein paar Gedanken zur allgemeinen Struktur der Entwicklung zu machen.
Klar ist es möglich alles irgendwie in die Haupt-Source-Code datei zupacken und ebenso kann man alles in einzelen Source Code dateien auslagern. Als Freund der Objektorientierten programmierung

Ein Homebrew Basisklasse

Im ersten Schritt wird eine einfache Homebrew-Basisklasse erstellt, welche die in jedem Homebrew immer wieder auftauchenden Grundfunktionnen bereitstellt un initialisiert. Jede Applikation kann diese Klasse dann erben und entsprechend spezialisieren.

Das Header-File dieser ersten Applikationsklasse sieht dann so aus:

/*
* Homebrew.h
*/

#ifndef HOMEBREW_H_
#define HOMEBREW_H_
class ClHomebrew {
public:

/*
* Initialisierung des Homebrews
*/
bool init();

/*
* Homebrew ausführen bis “HOME” Taste + Beenden
*/
void run();

/*
* Homebrew soll beendet werden, ggfl. speicher freigeben
*/
virtual void exit();

/*
* Destructor
*/
virtual ~clHomebrew();
protected:

/**
* die Klasse kann nicht direkt instanziiert werden -> singleton
* Konstrukor ist protected
*/
ClHomebrew();
virtual void mainthread();
};
#endif /* HOMEBREW_H_ */

Die Implementierung zu dieser Klasse sieht dann wie folgt aus. Hier finden wir einige Elemente aus unserem ersten Homebrew wieder.

/*
* homebrew.cpp
*
* Diese Klasse ist die Basisklasse für jede Art von Homebrew Entwicklung
*/

#include “homebrew.h”

extern “C” {
#include <pspdebug.h>

#include “callbacks.h”
}
void ClHomebrew::run()
{
// die Hauptschleife
while(running()){
/*
* so lange die Applikation nicht über die HOME-Taste
* beendet wurde diese Ausführen
*/
mainthread();
}
}

/**
* Initializierung der Homebrew - Callbacks etc.
*/
bool ClHomebrew::init(){
//Init des DebugScreens für Textausgabe
pspDebugScreenInit();

setupCallbacks();
return true;
}

void ClHomebrew::exit(){
}

/**
* Leerer Hauptthread/Programmablauf. Muss von der
* Ableitenden Klasse implementiert werden
*/
void clHomebrew::mainthread(){
}

clHomebrew::clHomebrew() {
}

clHomebrew::~clHomebrew() {
}

Die zweite Homebrew
Mit diesen Grundlagen können wir nun unsere zweite Homebrew schreiben die auf dieser Basisklasse aufsetzt.
Schritt 1: Zunächst legen wir eine “HalloWelt” Klasse als Ableitung der Basisklasse and und implementieren den “Mainthread”.
Schritt 2:Danach bauen wir die “main.cpp” entsprechend um und in
Schritt 3:Müssen wir noch das Makefile anpassen um unsere Applikation durch den Compiler zu bekommen

Von diesen Schritten beim nächsten mal mehr…..

Geschrieben in Erste Schritte | Drucken | Keine Kommentare »

20.11.2009 von AnMaBaGiMa.

Hallo Welt - oder ?

Das ist der Klassiker - oder ? Also wollen auch wir damit starten. Daran lässt sich sehr leicht die grundlegende Struktur erkennen und wir können dies sehr schnell ausbauen um unser Ziel zu erreichen: Ein PSP Spiel….Also los geht’s. Zunächst legen wir uns in eclipse ein neues C/C++ Projekt an. Wenn die Einstellungen in der IDE korrekt sind, dann werden bei der Projektanlage auch gleich alle Include-Pfade für die notwendigen Header-Dateien gesetzt. Nachdem das Projekt nun erfolgreich erzeugt wurde, wird die leere Hülle gefüllt. Es müssen mindestens 2 Dateien vorhanden sein.

Das Makefile

In dem “Makefile” - das genau so heißt und keine Dateiendung hat - wird beschrieben was der Compiler zu tun hat um unser PSP Homebrew zu erstellen. Für den ersten Start sieht das etwa so aus:

TARGET = pspdemo
OBJS = main.o
INCDIR =
CFLAGS = -G0 -Wall -g
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS
BUILD_PRX = 1
LIBDIR =
LDFLAGS =
LIBS=
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = PSP Demo
PSP_LARGE_MEM=1
PSP_FW_VERSION=150
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak

Das Hauptprogramm

Nachdem wir in unserem Makefile festgelegt haben, dass die Datei “main.o” zum Erstellen der Homebrew genommen werden soll müssen wir in unserem Projekt ein gleichnamige Datei mit der Dateiendung c oder cpp erstellen. In unserem Falle wird die Datei main.cpp heißen. Für ein erstes “Hallo Welt!” muss nicht viel getan werden. Eine Hauptroutine die das Homebrew initialisiert und dann in einer Schleife läuft bis die “home”-Taste der PSP gedrückt wurde.

Zunächst müssen wir einige header-Files einbinden. Da wir eine CPP-Datei nutzen müssen diese als externe “C”-Quelle eingebunden werden. Zusätzlich müssen ein paar feste Makros eingebunden werden die unser Homebrew initialisieren:

/*
* main.cpp
*
* The first simple homebrew
*/
extern “C” {
#include <pspdebug.h>
#include <pspkernel.h>
}
PSP_MODULE_INFO(“PSP Demo”, 0, 1, 1);
PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);

Kommen wir nun zur eigentlichen Hauptroutine. Diese initialisiert die PSP Callbacks, schreibt was auf den Bildschirm und wartet auf die “home”-Taste:

int main(int argc, char* argv[]){//initialisieren Screen
pspDebugScreenInit();
//initialisieren der Callbacks
setupCallbacks();
pspDebugScreenPrintf(“Hallo Welt!”);
while(running()){
}
//Homebrew verlassen
sceKernelExitGame();
return 0;

Die zwei Routinen setupCallbacks und running werden im Grunde in jeder Homebrew gebraucht. Darum macht es Sinn diese zentral für jedes Project verfügbar abzulegen und wieder zu verwenden. Die Dateien callbacks.h und callbacks.c sind in dem Beispielverzeichnis des SDK zu finden. Es bietet sich an diese beiden Dateien in einem Ordner “common” unterhalb des Workspace Ordners zu platzieren. Wenn das erledigt ist muss das Makefile und das Hauptprogramm noch leicht erweitert werden. Das Hauptprogramm um folgendes Include:
#include“../common/callbacks.h”Das Makefile muss in der liste der Dateien folgendermaßen ergänzt werden:
OBJS = main.o ../common/callbacks.o

Wenn wir nun alles beisammen haben und das Projekt hoffentlich fehlerfrei erstellen konnten, dann sieht das ganze auf der PSP - völlig unspektakulär - folgendermaßen aus:

Geschrieben in Erste Schritte | Drucken | Keine Kommentare »