DGL • Thema anzeigen - BroodTech Game Engine

BroodTech Game Engine

Moderator: DGL-Team

Seite 1 von 2

[ 17 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

yunharla

Betreff des Beitrags: BroodTech Game Engine

Verfasst: Mi Apr 03, 2013 09:32

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

BroodTech Game Engine

Die BTGE ist eine Grafik Engine und Script Interpreter, speziell für klassische Textspiele. Den Kern bildet dabei eine "Konsole" für die Text Aus- und Eingaben. Diese "Konsolenanwendung" wird in der hauseigenen Scriptsprache geschrieben und diktiert den gesamten Programmablauf.

Ueber den "draw"-Befehl kann das Bild auf verschiedene Weise geteilt werden um einen Bereich für grafische Ausgabe zu schaffen. Hierfür koennen Sprites aus Bild- oder 3D-Daten geladen und animiert werden.

Bisher Implementiert:
- TextScript
- Dark Radiant .map loading
- Texture loading
- Garbage Collection
- Midi loading \m/

Noch zu erledigen:
- Radiosity Shader (~30%)
- Animationen (~20%)
- Erweiterung von TextScript (never ending story

)

zum Schluss noch ein Screenshot vom CSG System

Dateianhänge:

screenshot1.PNG [149.65 KiB]
Noch nie heruntergeladen

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Mo Apr 08, 2013 14:45

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Mal ein kleines Update vom Wochenende:

Scripte

- Neben normaler Texteingabe steht nun auch die "bind {key} {Funktion}" Anweisung zur Verfügung. Auf diese Weise kann man zum Beispiel auch die Cursor Tasten verarbeiten.

Renderer

- GLSL support

- Deferred Sharing wurde eingebaut.

- Dazu noch: Ich habe begonnen einen Raytracer zu implementieren. Dieser soll dann die Lichtpunkt für Instant Radiosity erzeugen.

- Frame Updates prüfen nun das Datum von verwendeten Dateien, und lädt diese bei Aktualisierungen neu.

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Di Apr 16, 2013 19:56

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Renderer
Die Präzision der Texturen vom Render-To-Texture wurde erhöht. Dadurch können nun auch größere Maps gut dargestellt werden.

Radiosity wurde rausgeschmissen da es zu crappy aussah und zu viel Performance gefressen hat. Dafür gibts nun hübsche Spotlichter

Scripte
Der Befehl "move" (Variablen Zuweisung) kann nun auch Terme verarbeiten.

Der Befehl "free" (Bildschirm löschen) hat nun noch einen optionalen Boolean Parameter. Über diesen kann man bestimmen ob Grafik oder Text gelöscht wird. Default ist sozusagen "jein", also beides.

Dateianhänge:

btge1.PNG [134.33 KiB]
Noch nie heruntergeladen

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Apr 18, 2013 20:21

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

hab gerade einen Compiler für eine einfachere Form der Scripte geschrieben. Dieser übersetzt die C ähnlichen Scripte in die
11 Textbefehle der Engine.

Code:

 
// c-style comments
/*      .____          .____     
 *      |    |    ____ |    |    
 *      |    |   /  _ \|    |    
 *      |    |__(  <_> )    |___ 
 *      |_______ \____/|_______ \
 *              \/             \/
 */
 
portrait("throne.map");
 
//Funktionen
void guessHallo(number counter) {
    string test = readln();
    //if statements
    when(counter,"^0")
        return;
    //blöcke
    when(test,"^hallo") {              
        print("thats right!");
        return;
    }
    print("thats wrong, please try again.");
    //operatoren (gibts auch für strings ;))
    guessHallo(counter - 1);
}
guessHallo(5);
print("press any key to close");
readkey();
 

Die Library umfasst derzeit folgende Funktionen:
print(string, ... of string)
==>Textausgabe
sleep(number)
==>N-Millisekunden warten
when(string,string)
==>Eine Regex über den ersten String matchen
landscape(string)
==>.map Datei laden und im vertikalen Modus ausgeben
portrait(string)
==>.map Datei laden und im horizontalen Modus ausgeben
clrscr();
==>Grafische Ausgabe löschen
clrtxt();
==>Textausgabe löschen
string readkey();
==>Taste auslesen
string readln();
==>Zeile auslesen
string read(number);
==>N-Tasten auslesen

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Mai 16, 2013 17:49

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Die letzten Tage habe ich an einen Nachfolger für eine meiner Bibliotheken, namens libcrpt, gearbeitet. Diese woche ist nun die libcrpt2 fertig geworden und die letzten beiden Tage habe damit verbracht sie in die Engine einzubauen. Dadurch können nun der bisherige Interpreter, Mapparser und die kommenden Scripte endlich vereinheitlich werden. Der Mapparser ist schon erledigt und die Gamescripte umfassen schon jetzt:

Schleifen (while,do-while,for,foreach)
Branching (if,else,switch,goto,return,label,usw. )
Funktionen
Variablen
Blockstatments
alle möglichen Expressions
Storageclass (static, ref, const, extern)
Ellipsen
Anonyme Funktionen
Garbage Collection
Fiber

Void
Bool
Integer
Float
String
Delegaten (\m/)

Try
Catch
When (wie bei VB)
Fault
Throw

blah blah blah ... typedefs fehlen leider noch um die wirklich coolen Dinge zu machen

naja stellt euch einfach vor C# wäre mehr C als Java....

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Fr Jul 19, 2013 17:13

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

So der Prototyp ist fertig und wird nun nach Objective-C (gnu-runtime) uebertragen. Die letzten Tage habe ich erst einmal massive bug-fixes und refactoring an der general obj-c lib vorgenommen (release kommt) bald und den boehm-gc compeliert (koennen diese Linuxpunker nicht mal nen funktionierenden installer oder sowas schreiben?). Ansonsten ist von der Engine selbst schon ein sehr grosser Teil konvertiert worden.

So pi mal Daumen fehlen also nur noch:
-die objective-c runtime
-der script-interpreter
-der 3D-Modus

achja und das Projekt wird Open Source (Schnapps Lizenz)

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Mi Jul 31, 2013 09:31

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Update Time *wuuuuuush* :mrgreen:

:

Ich habe die letzten Tage damit begonnen die Objective-C Runtime zu implementieren und libobjc rausgeschmissen. Zur Zeit unterstuetzt meine Version die grundlegenden OOP Features wie Klassen, Instanzen und Vererbung (voll geil das man den Kram selbst schreiben kann :mrgreen:

). Des Weiteren ist die Speicherverwaltung auch etwas einfacher da alle nicht-konstanten Pointer zusammen mit der Instanz selbst freigegeben werden. Grob gesagt kann man also schon ziehmlich gut damit arbeiten. Fuers erste fehlen noch Kategorien, Protokolle und Properties.

Achja bei einen kleinen Experiment hat sich uebrigens eine meiner Vermutungen bestaetigt. Es ist naemlich moeglich waerend der Laufzeit einen Wrapper um jeden Funktionsaufruf (innerhalb der Runtime) zu legen. Ich bin mir noch nicht ganz sicher ob ich das wirklich nutzen will (ellipse nach ellipse halt -.-), aber es koennte zu ein paar wirklich coolen Features fuehren.

[edit]
achja wer will kann Zugang zum GIT bekommen, einfach PM an mich dann.

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Sep 19, 2013 12:31

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Ok ich war in letzter Zeit etwas knapp mit Updates (zuviel Mechwarrior

), das soll sich aber nun ändern.

Ich habe mich nun doch gegen den Garbage Collector entschieden. Es wäre einfach zuviel Arbeit für ein mehr oder weniger instabiles Feature gewesen. Dafür gibt es aber nun eine einheitliche Speicherverwaltung für Objective C und normale C Typen. Das tolle daran ist dass hier auch gleich alle inneren Referenzen freigegeben werden wenn ein Objekt gelöscht wird, außer wenn der Compiler oder Programmierer diese als Strong-Pointer gekennzeichnet hat.

Des Weiteren sind die Funktion "strex" und der "heap" Datentyp nun fertig. "strex" ist für die Evaluation von Ausdrücken in String-Form zuständig und somit der wohl wichtigste Bestandteil des Interpreters. Beim Design habe ich mir folgende Regeln aufgestellt:
-Alles ist eine Zahl vom Typ Double,Long Integer oder Boolean.
-Alle Nicht-Zahlen und nicht Operatoren sind externe Funktionen die Zahlen zurückgeben.
-Alle unären Operatoren stehen vor dem Operanden, also z.B. nur ++i und kein i++
Wenn nun z.B. ein String-Literal kommt dann muss dieser von einer, zuvor registrierten Funktion, in eine Addresse umgewandelt werden.

Mindestens genauso wichtig wie die "strex" Funktion ist die Heap Struktur. Diese dient vor allen dazu Addressen zu verwalten und orientiert sich von der Funktionsweise an das gute alte "malloc" und "free". Einen Wrapper wie bei der normalen Speicherverwaltung sollte ohne Probleme möglich sein (man muss ja so oder so Reflection einbauen).

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Mi Aug 13, 2014 22:02

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Lange ist es her das sich hier mal was getan hatte. Heute habe ich endlich mal wieder etwas Zeit gefunden. Und wie das so ist fand ich meinen Code mittlerweile eher suboptimal

Für die neue "Version" habe ich erst einmal das Projekt in Netbeans, statt DevCpp aufgesetzt. Für Objective-C ist es zwar genauso gut, dafür ist aber der normale C Code wesentlich besser. Und im Gegensatz zu Eclipse muss man keine große Magic zum Verwalten der Code-Dateien machen. Nachdem das in 2h erledigt war (fragt lieber nicht), habe ich nun erst einmal die Runtime ins neue Projekt geholt. Dabei habe ich auch gleich einmal etwas aufgeräumt und so weiter.

Morgen nach der Arbeit geht es dann weiter mit der Allgemeinen Basis-Klasse. Dabei will ich vor allen Speicherverwaltung etwas aufpolieren um mehr als brutale dynamische Allokation zu machen.

Zum Schluss noch der Quellcode der neuen Runtime:

Code:

 
 
/* 
   BroodTech Objective-C Runtime
   Created by Alex 'YunHarla' Schmidt
 
The following provides a more lightweight version of the objective-c
runtime I found with my MINGW installation. Since I'm no lawyer I just
include the original copyright, I found with it's source. If stuff 
needs to be changed or if you have improvements / bug reports you can
send me an email at <info@broodtech.de>
 
   GNU Objective-C Runtime API - Modern API
   Copyright (C) 2010 Free Software Foundation, Inc.
   Contributed by Nicola Pero <nicola.pero@meta-innovation.com>
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
License for more details.
 
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
 
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */
 
#include <string.h>
#include <objc/runtime.h>
 
//the following types and definitions are taken directly from the
//original source... just with typedefs instead of just struct 
//because most people i know may mistake it for a local variable otherwise.
#define __CLS_INFO(cls) ((cls)->info)
#define __CLS_ISINFO(cls, mask) ((__CLS_INFO(cls)&mask)==mask)
#define _CLS_META 0x2L
#define CLS_ISMETA(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_META)) 
#define _CLS_CLASS 0x1L
#define CLS_ISCLASS(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_CLASS)) 
 
typedef struct objc_list {
    void *head;
    struct objc_list *tail;
} objc_list_t;
 
//because this stuff only is done ONCE during initialization i don't really
//care about deallocation here. You might want to use the original objc-list 
//header (<objc/objc-list.h>) instead.
static objc_list_t objc_lists[0xFFFFF];
static objc_list_t* cur_objc_list_head = &(objc_lists[0]);
 
struct objc_list* objc_list_cons(void* head, struct objc_list* tail) {
    struct objc_list* cell;
    cell = cur_objc_list_head++;
    cell->head = head;
    cell->tail = tail;
    return cell;
}
 
typedef struct objc_symtab {
    unsigned long sel_ref_cnt;
    struct objc_selector *refs;
    unsigned short cls_def_cnt;
    unsigned short cat_def_cnt;
    void *defs[1];
} objc_symtab_t;
 
typedef struct objc_module {
    unsigned long version;
    unsigned long size;
    const char* name;
    struct objc_symtab *symtab;
} objc_module_t;
 
typedef struct objc_static_instances {
    char *class_name;
#ifdef __cplusplus
    id instances[1];
#else
    id instances[0];
#endif
} objc_static_instances_t;
 
typedef struct objc_method {
    char* method_name;
    const char* method_types;
    IMP method_imp;
} objc_method_t;
 
typedef struct objc_method_list {
    struct objc_method_list* method_next;
    int method_count;
    struct objc_method method_list[1];
} objc_method_list_t;
 
typedef struct objc_ivar {
    const char* ivar_name;
    const char* ivar_type;
    int ivar_offset;
} objc_ivar_t;
 
typedef struct objc_ivar_list {
    int ivar_count;
    struct objc_ivar ivar_list[1];
} objc_ivar_list_t;
 
struct objc_super {
    id self;
    Class super_class;
} objc_super_t;
 
//this is my replacement for the original hash tables
//because a tree was slightly of faster for me
typedef struct objc_cls_tab_node {
    char key;
    Class value;
    struct objc_cls_tab_node * next;
    struct objc_cls_tab_node * first;
} objc_cls_tab_node_t;
static objc_cls_tab_node_t cls_tab[0xFFFF];
static objc_cls_tab_node_t * cur_cls_tab_head = &(cls_tab[0]);
static objc_list_t *uninitialized_statics = 0;
 
//NOTE:
//the following two methods are the great bottlenecks
//of objective-c. They are called in almost any case
//and you cannot use the designated fields because
//a pointer to a name or selector or class may change. 
 
//Returns the class associated with the c-string pointed
//to by name. The compiler automatically inserts this 
//in numerous occasions. For example when the code calls
//a static method
Class objc_get_class(const char *name) {
    objc_cls_tab_node_t * tab = &(cls_tab[0]);
    while (*name && tab->first) {
        tab = tab->first;
        while (tab->key != *name) {
            tab = tab->next;
        }
        name++;
    }
    return tab->value; //if we return null it will crash anyway, so let's ignore error handling
}
 
 
 
//Return a method with the signature pointed to by op 
//from the class pointed to by cls. This is called 
//EVERYTIME objective-c does calls some class or instance
//method. 
IMP get_imp(Class cls, SEL op) {
    if (cls) {
        if (CLS_ISCLASS(cls) || CLS_ISMETA(cls)) {
            objc_method_list_t * method_list = cls->methods;
            while (method_list) {
                for (int i = 0; i < method_list->method_count; i++) {
                    objc_method_t * m = &(method_list->method_list[i]);
                    if (strcmp(op->sel_id, m->method_name)) {
                        continue;
                    }
                    if (op->sel_types) {
                        if (strcmp(op->sel_types, m->method_types)) {
                            continue;
                        }
                    }
                    return m->method_imp;
                }
                method_list = method_list->method_next;
            }
            
            const char * superclass = (char *) cls->super_class;
            if (superclass) {
                if (CLS_ISMETA(cls))
                    return get_imp(objc_get_class(superclass)->class_pointer, op);
                else
                    return get_imp(objc_get_class(superclass), op);
            }
        }
 
    }
    return NULL;
}
 
//This automatically gets inserted by the compiler and 
//initializes all classes and statics of a module 
//(source file). It's guaranteed to be called before
//a class is used, however most compilers will use
//this right before the "main" method is invoked.
void __objc_exec_class(struct objc_module *module) {
    static unsigned char init = 1;
    if (init) {
        memset(cls_tab, 0, sizeof (cls_tab));
        init = 0;
    }
    objc_symtab_t * symtab = module->symtab;
    void ** defs = symtab->defs; 
    int i = 0;
    int num_classes = symtab->cls_def_cnt; 
    for (; i < num_classes; i++) {
        objc_cls_tab_node_t * tab = &(cls_tab[0]);
        Class cls = (Class) defs[i];
        const char * name = cls->name;
        //insert a name into our class tree
        while (*name) {
            //move to and maybe create the next level of our tree
            //each level stores every possible character for the current
            //position
            if (tab->first) { 
                tab = tab->first;
            } else { //no node for this length so create and assign a new one
                tab = tab->first = cur_cls_tab_head++;
                tab->key = *name;
            }
            //check each added character of the current level
            while (tab->key != *name) {
                if (tab->next) {
                    tab = tab->next;
                } else { 
                    //no node for this character so create an assign a new one
                    tab = tab->next = cur_cls_tab_head++;
                    tab->key = *name;
                }
            }
            name++;
        }
        tab->value = cls;
    }
    //initialize static instances (if any) or resume initializing
    //all previous uninitialized statics. Statics are stuff like
    //constant strings (which store the LENGTH!!!!).
    objc_static_instances_t ** statics = defs[i + symtab->cat_def_cnt];
    if (statics) {
        uninitialized_statics = objc_list_cons(statics, uninitialized_statics);
    }
    if (uninitialized_statics) {
        objc_list_t **cell = &uninitialized_statics;
        struct objc_static_instances **statics_in_module;
        while (*cell) {
            unsigned char module_initialized = 1;
            Class cls;
            for (statics_in_module = (*cell)->head;
                    *statics_in_module;
                    statics_in_module++) {
                objc_static_instances_t *mod_statics = *statics_in_module;
                cls = objc_get_class(mod_statics->class_name);
                if (cls) {
                    id * inst;
                    //ignore any protocol
                    if (strcmp(mod_statics->class_name, "Protocol")) {
                        for (inst = &(mod_statics->instances[0]); *inst; inst++) {
                            (*inst)->class_pointer = cls;
                        }
                    }
                } else {
                    module_initialized = 0;
                }
            }
            if (module_initialized) {
                cell = &((*cell)->tail);
            } else {
                break;  //we don't have all classes yet so hopefully resume this 
                        //when the next module is loaded.
            }
        }
    }
}
 
 
Class objc_get_superclass(Class cls) {
    if (CLS_ISMETA(cls) || CLS_ISCLASS(cls)) {
        const char * superclass = (char *) cls->super_class;
        Class supercls = objc_get_class(superclass);
        if (CLS_ISMETA(cls))
            return supercls->class_pointer;
        return supercls;
    }
    return NULL;
}
 
 
IMP objc_msg_lookup(id receiver, SEL op) {
    if (receiver) {
        return get_imp(receiver->class_pointer, op);
    }
    return NULL;
}
 
IMP objc_msg_lookup_super(struct objc_super *super, SEL op) {
    if (super->self) {
        const char * superclass = (char *) super->self->class_pointer->super_class;
        Class supercls = objc_get_class(superclass);
        if (CLS_ISMETA(super->self->class_pointer))
            return get_imp(supercls->class_pointer, op);
        else
            return get_imp(supercls, op);
    }
    return NULL;
}
 

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Aug 14, 2014 22:22

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Ok habe jetzt die "Object"-Klasse fertig. Ich habe mich hier dazu entschieden die Speicherverwaltung komplett von "Außen" abzuwickeln. Sprich die Klasse selbst übernimmt keinerlei Allokation bzw. Deallokation. Stattdessen gibt es nur Funktionen zum (De-)Initialisieren von Puffern. Das hat den großen Vorteil das man zum Beispiel Objekte auf den Stack legen kann.

Code:

 
@interface Object {
    Class class_pointer; 
}
//sets the class pointer to the memory pointed to by buffer
//a class pointer must exist in order to class instance methods.
//This function has an overload with bound checks.
+(id) Init: (void*) buffer; 
+(id) Init: (void*) buffer With: (size_t) size; 
//Returns the objective-c class structure that is used to
//by class pointers in objects
+(Class) Class; 
-(Class) Class;
//Returns the number of bytes an object
//requires to store the class pointer and all
//additional instance variables
+(size_t) Size;
-(size_t) Size;
//Checks if the current object is assignable to 
//the class pointed to by cls
-(BOOL) IsKindOf:(Class) cls;
//Sets all bytes occupied to Zero. You may 
//override this to do additional before the object
//gets destroyed.
-(void) Uninit;
@end
 

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Sa Aug 16, 2014 22:02

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

So noch mal kurz ein kleiner Nachtrag zur Speicherverwaltung. Ich habe mich nun dazu entschlossen das ganze Projekt per semi funktionaler Programmierung umzusetzen. Sprich alle Objekte existieren nur solange wie der aktuelle, oder der vorherige bei "return", Stack-Frame einer Funktion:

Zuerst habe ich mir einmal die "alloca" Implementierung von "libiberty" angeschaut. Hier wird zuerst ermittelt in welche Richtung sich der Stack ausbreitet. Basierend auf der Stack-Richtung, kann der Allokator jetzt ein Offset zum "root"-Frame ermitteln. Alle vorherigen Allokationen die ein größeres Offset haben können dabei freigegeben werden.

Jetzt braucht man nur noch einen Mechanismus der ein Objekt zurückgibt. Dazu muss man einfach die jeweilige "Variablen" zum nächst höheren Offset verschieben.

Code:

 
 
typedef struct objc_var_s objc_var_t;
struct objc_var_s {
    size_t size;
    BOOL is_free; 
    objc_var_t * next; 
    objc_var_t * prev; 
};
 
static int STACK_DIR = -1;
#define STACK_DEPTH 0xFFFF
static size_t objc_stack[STACK_DEPTH ];
static void * objc_mem_ptr[STACK_DEPTH ]; 
static unsigned short objc_stack_head = 0;
 
static byte objc_memory[SYSTEM_MEMORY_SIZE + sizeof(objc_var_t)];
static objc_var_t * objc_mem_var = NULL;  
static size_t objc_used_memory = 0;
 
void objc_make_stack_dir(void) { 
    static char * addr = NULL;
    auto char tmp; //some variable on the current stack-frame
    if(addr) {
        if(&tmp < addr) { 
            STACK_DIR = 1; //stack frame uses forward growth
        } else {
            STACK_DIR = 0; //stack frame uses backward growth
        }
    } else {
        addr = &tmp; //assign a pointer to memory on the current stack-frame
        objc_make_stack_dir(); //increase the stack-frame
    }
}
 
//initialize the memory ring-buffer 
void objc_init_memory(void) { 
    objc_mem_var = (objc_var_t*)&(objc_memory[0]); 
    objc_mem_var->size = SYSTEM_MEMORY_SIZE;
    objc_mem_var->next = objc_mem_var; 
    objc_mem_var->prev = objc_mem_var; 
    objc_mem_var->is_free = YES;
    objc_used_memory = 0;
}
 
//allow memory pointed to by ptr to be reused by the system
void objc_dealloc(void * ptr) {
    objc_var_t * block = (objc_var_t*)((byte*)ptr - sizeof(objc_var_t));
    objc_var_t * start = block;
    if(block->is_free) {
        return;
    }
    objc_used_memory -= block->size;
    block->is_free = YES;
    //join previous squential free buffer items
    while(block->prev->is_free && block->prev != start) { 
        block = block->prev;
    }
    objc_mem_var = block;
    //join next squential free buffer items
    while(block->next->is_free && block->next != start) {
        block->size += block->next->size;
        block->next = block->next->next;
        block->next->prev = block;
    }
}
 
void * objc_alloc(size_t size) {
    objc_var_t * base = objc_mem_var;
    objc_var_t * start = base;
    size += sizeof(objc_var_t); //add space for the buffer item
    size = (size + 7) & ~7; //align memory
    while(base) { //search any free buffer with enough space
        if(base->is_free) {
            if(base->size > size) {
                break;
            }
        }
        base = base->next;
        if(base == start) {
            return NULL;
        }
    }
    //split our buffer if we have a good amoun of memory left
    if ((base->size - size) >= 64) {
        objc_var_t * next = (objc_var_t*)((byte*)base + size);
        next->size = base->size - size;
        next->is_free = YES;
        next->prev = base;
        next->next = base->next;
        base->next = next;
        base->size = size;
    }
    //mark a non-free and return a pointer to the first byte after the buffer item
    base->is_free = NO;
    objc_mem_var = base->next;
    objc_used_memory+= base->size;
    return (void*) ((byte*)base + sizeof(objc_var_t));
}
 
 
void * objc_stack_alloc(size_t size) {
    static char * root = NULL;
    auto char tmp;
    register char * level = &(tmp);
    if(STACK_DIR == -1) {
        objc_make_stack_dir();
    }
    if(root == NULL) {
        root = level; //this is the first stack-allocation so lets set a good size
        objc_init_memory();
    }
    ptrdiff_t offset = 0; 
    if (STACK_DIR) {
        offset = level - root;
    } else {
        offset = root - level;
    }
    while(offset < objc_stack[objc_stack_head]) { //collect garbage
        objc_dealloc(objc_mem_ptr[objc_stack_head]);
        objc_stack_head--;
    }
    void * out = objc_mem_ptr[++objc_stack_head] = objc_alloc(size);
    objc_stack[objc_stack_head] = offset;
    return out;
}
 
 
void * objc_stack_retain(void * ptr) {
    //todo
    return ptr;
} 
 
 

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Aug 28, 2014 07:54

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Gestern Abend habe ich mal wieder mit dem Boehm Garbage Collector rumgespielt. Und siehe da, das Ganze laeuft jetzt stabil (muss wohl ein Fehler im alten Code gewesen sein). Noch dazu ist die Speicherverwaltung fast genauso schnell wie die vorher beschriebene Stack-Variante. Also habe ich kurzer Hand die Stack-Version rausgeschmissen und durch den GC ersetzt.

Das Ganze funktioniert jetzt ungefaehr wie folgt:

alloc (Klasse, extra_size)
-klassen GC-type laden fuer Klasse-Name
--Wenn GC-type NULL ist, dann erstelle einen neuen GC-type fuer die Klasse
-GC_malloc_typed(Klasse->instance_size,extra_size,GC-type)
-memset auf 0
-Klassen Zeiger setzen

und fertig :-)

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Di Sep 16, 2014 20:16

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Und mal wieder ein paar kleinere Updates:

- "Static" Klasse für statische Klassen
- Superklassen werden jetzt direkt in der Klasse gespeichert statt nur der Name.
- Kategorien
[edit]
achja ganz vergessen:

Code:

 
 
@interface Handle {
    @private
    Class class_pointer;
}
+(Class) Type; //gets the type of the current class
-(Class) Type; //gets the type of the current object
-(bool) Is:(Class) cls; //checks if the object is assignable to the given class
@end
 
@interface Dynamic {
}
+(id) Alloc; //allocates and returns an instance of a garbage collected object
-(void) Dispose; //automatically called when the object will be deallocated by the garbage collector or Dealloc method.
-(void) Dealloc; //manually deallocate the current object
@end
 
@interface Static {
    bool isLoaded; 
}
+(id) Current; //returns the instance for the static class
-(id) Load; //automatically called by the Current method and when the object is not loaded 
-(void) Unload; //automatically called when the process terminates and marks the object as unloaded
 
@end

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Okt 09, 2014 20:50

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Mal wieder ein kleines Update:

ich nutze jetzt meinen Mini Collector zur automatischen Speicherbereinigung. Im Gegensatz zur der im Thread geposteten Version hat meine Version einige zusätzliche Features:

-Range Checks um zum Beispiel Pointer Arithmetik zu unterstützen.
-De- und Initialisierung finden in den Startup Funktionen statt. Also zum Beispiel WinMainCRTStartup.
-Finalizer und Class Finalizer
-OpenMP Beschleunigung
-Der GC-thread wird jetzt über ein "Join" beendet statt nur terminiert
-C++,C und Objective-C Support

Die Static-Klasse ist jetzt die Module-Klasse. Die Module rufen bei Benutzung automatisch die
Load-Methode auf und registrieren Unload als Class-Finalizer. Dies erlaubt mir jetzt relativ entspannt das Fenster-System und dynamische Bibliothek (wie OpenGL) zu laden. Außerdem fliegt die Dynamic Klasse raus, da auch Module Instanzen brauchen (z.B. für GL-Extensions).

Außerdem habe ich jetzt meine Objective-C Toolchain auf C11 und 64bit geupdated

_________________
Meine Homepage

Nach oben

yunharla

Betreff des Beitrags: Re: BroodTech Game Engine

Verfasst: Do Dez 18, 2014 00:04

DGL Member

Registriert: Mo Nov 08, 2010 18:41
Beiträge: 769
Programmiersprache: Gestern

Hallo Allerseits,

Es ist mal wieder Urlaub- /Ferienzeit und das bedeutet natürlich endlich mal wieder Zeit für die wichtigen Dinge im Leben: OpenGL

Die letzten Tage habe ich damit verbracht die gesamte Engine mal wieder komplett umzuschreiben. Herausgekommen ist nun eine solide Basis welche die, meiner Meinung nach, besten Elemente der bisherigen Arbeit vereint. Der wohl wichtigste Punkt dabei ist der neue Multithreading Support und damit verbunden der Umstieg von Objective-C auf C++. Oder besser gesagt den Syntax-Sugar durch Objective-C, denn vieles funktioniert tatsächlich noch genauso. Sprich Objekte erhalten Nachrichten anstelle von direkten Funktionsaufrufen.

Der Große Unterschied liegt nun darin das ich den kompletten "Aufruf" in einer Queue zwischenspeichere. Der Dispatcher entscheidet dann automatisch, ob die Queue sofort (z.B. wenn eine Rückgabe erwartet wird) oder zu einen späteren Zeitpunkt abgearbeitet wird. Auf diese Weise kann ein Objekt sehr leicht von mehreren Threads benutzt werden ohne das man sich große Gedanken um die Synchronisation machen muss.

Würde man ein ähnliches Verhalten mit Objective-C erziehlen wollen müsste man auf Asm zurückgreifen oder den Compiler nachbearbeiten. Beides war für mich keine Option, also Umstieg.

Das neue Macro-Design der Engine sieht nun wie folgt aus:
Abstract Thread
- Send Message
- Process Message

Main-Thread
-Alles Starten und Beenden.
-Schleife für den Input und co.
->Events an den Client senden.
Client-Thread
- Interaktion mit der Szene
->Commands an den Renderer senden.
->Events an den Server senden.
Renderer-Thread
-Commands verarbeiten
Server-Thread
-Aufbau / Update der Szene
->Events an den Client senden.
GC-Thread
-Speicher scannen und aufräumen.

_________________
Meine Homepage

Nach oben

Seite 1 von 2

[ 17 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Sonstiges » Projekte

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.