Forenbeiträge von userid11997 Ingesamt 400 Beiträge
Spiele-Engine: Kann man physikalische Regeln auf soetwas wie Magie o. Geistererscheinungen anwenden?
Aber zumindest habe ich dann für meine Welten ein paar gültige Regeln, was das betrifft 😁
Und ich glaube, dass wenn wir sowas auslaern , wir nicht mehr ganz so viel in dem Bereich jedesmal neu mahen brauchen , sprich Arbeitsersparnis
Spiele-Engine: Kann man physikalische Regeln auf soetwas wie Magie o. Geistererscheinungen anwenden?
WOW... nein das können sie nicht. setz denen einen massiven marmorblock vor und die schaffen das nicht 😉
Aber angeblich eine Nadel durch eine Glasscheibe werfen 🤔
Wenn wir sterben, ist diese Energie also noch in Form von gebundenen Stoffen in unserem Körper, die bei der Zersetzung durch Bakterien von diesen aufgenommen und verarbeitet/verbraucht werden. Dabei entsteht dann in der Regel Wärme, genau wie beim Laufen, wo wir ins Schwitzen kommen, damit unser Körper wieder abkühlt.
Von daher hat das nichts mit irgendwelchen Energiefeldern oder Ähnlichem zu tun, sondern ist alles rational und naturwissenschaftlich erklärbar.
Ja , wobei die Physik da wieder ganz andere Gesetzmäßigkeiten aufzeigt , beispielsweise das Nervensystem basiert auf elektrischer Energie.
Dazu dann noch , das jedes Elementarteilchen ( zu denen auch Stoffe zählen, da sie aus diesen Teilchen bestehen) Energie besitzt. Das Gehirn beispielsweise besitzt auch elektromagnetische Energie , die kann aber nicht ohne weiteres gespeichert werden und ist daher auch nicht dem Zellolaren zerfall unterlegen. Was passiert wohl dammit?
Auch im hinblick darauf , dass von Lassi gesagt wurde , dass für ihn Geister eine Art Magnetfeld sein könnten.
Im Grunde möchte ich ja nur die Welt des unerklärlichen in feste Regeln fassen.
Es geht mir nämlich erhlich gesagt auf den Wecker , wenn in dem einen Spiel es so und so gemacht wird und in dem anderen wieder anders.
Die macher biegen sich die Welt des Magischen zurecht wies ihnen gerade passt.
Spiele-Engine: Kann man physikalische Regeln auf soetwas wie Magie o. Geistererscheinungen anwenden?
Insofern machst du hier m.E. den selben Fehler wie in
> , wo du versuchst, der DNA durch die Interpretation als Folge von OP-Code eine Bedeutung zu geben, die jeglicher gesicherten Grundlage entbehrt.
herbivore
Wie du meinem letzten Post zu diesem Thema villeicht entnehmen kannst , gibt es durchaus fundierte Grundlagen , die auf so eine Annahme schließen lassen!
Ich nehme hier als Beispiel auch mal die Shaulin-Mönche , die anscheinend sehr gut in der Lage sind den Energiefluss in Ihrem Körper zu manipulieren um z.b. Steine zu zertrümmern.
Es kann durchaus möglich sein , das wir Menschen in der Lage sind unserer eigene Energie umzuwandeln , bsp. in Wärmeenergie , dass es aber nur nicht geht , weil unser Verstand sich dagegen sträubt.
Ich könnte mir durchaus vorstellen , dass man mit dem Richtigen Ansatz und viel Übung auch nur mit seiner eigenen Energie z.b. die Luft zum brennen bringen könnte.
Das bringt mich auf die Frage , wieso gibt es überhaupt Leben?
Handelt es sich wirkluch nur um schlichte biologische Zufälle oder hängt es mit Energiemustern zusammen?
Wenn das so wäre , wo geht die Energie hin wenn der Körper stirbt? Wandelt si sich in irgendwas anderes um oder bleibt sie in dieser Konstelation erhalten?
Wenn das so wäre , könnte man auch hteoretisch mit allen Lebewesen über den Austausch dieser Muster kommunizieren.
Spiele-Engine: Kann man physikalische Regeln auf soetwas wie Magie o. Geistererscheinungen anwenden?
Moin,
im Rahmen der Arbeit an unserer BioEngine habe ich mir die Grundsatzfrage getellt, ob man nicht auch physikalische Regeln auf soetwas wie Magie oder Geistererscheinungen anwenden kann.
Ein Feuerzauber beispielsweise wäre doch bloß eine kontrollierte herbeiführung von umwandlung beliebiger Energie in Wärmeenergie.
Ein Geist wäre doch nichts anderes als Wellen , die ähnlich eines lebenden Organismus, muster von Abläufen innehat , die wie eine Zelle lebendig reagiert.
Telekinese wäre bloß eine umwandlung dieser Energie in Bewegung etc.
Dabei baiert das ganze System schlicht auf den Regeln der Energie. Ob Wellen oder Teilchen.
Ich überlege dies in eine SpiritEngine zusammenzufassen , die für Spiele , feste Regeln für z.b. die Entwicklung magischer/übersinnlicher Fähigkeiten eines Charackters festlegt.
Auch wenn das Thema auf den ersten Blick unnatürlich erscheint , wäre es durchaus Wissenschaftlich erklärbar.
Was habt ihr für eine Meinung dazu?
Ich gehe davon aus, dass in der DNA alles weit weniger direkt festgelegt ist, als man sich das als Mensch vielleicht wünschen würde.
Man kann nicht einfach per OP-Code die 35 in 60 bzw. die 9,3 in 8,3 ändern.
Das ist sicherlich Richtig , allerdings ist es im Gegenteil auch so , dass du nicht beweisen kannst , dass es nicht so ist.
Tatsache ist jedenfalls , dass es nicht erforscht ist und daher jede Menge Platz für Theorien bietet. Ich kann es nicht beweisen , villeicht rechnet die Natur auch nur mit 1 und 0 oder es sind ganz und gar andere Gegebenheiten, aber , solange es nunmal so ist , habe ich diese Theorie , auch im Wissen , dass es viele Menschen anders sehen , werde sie aber jedoch vertreten. Auch wenn ich den Befehlssatz frei entwickelt habe , denke ich trotzdem , dass die Natur ein ähnliches Schema haben könnte!
Ich denke nicht , dass du die Grundsatzdiskussion der Quantenphysiker nachverfolgt hast oder? Da ging es nämlich um das selbe Thema.
Ein paar Physiker haben , weil sie es sich nicht anders erklären konnten , einfach dem Universum eine Form der Energie hinzugedichtet , um Planetenmodelle koreekt darstellen zu können. Daraus ist das Theorem der dunklen Materie entstanden , das von den einen Physikern befürwortet und von den anderen strickt verteufelt und abgelehtn wird.
Ich fürchte , dass dieses hier zu einer ähnlichen Grundsatzdiskussion führen wird.
Ich hab versucht, mich bei Wikipedia über die Funktionsweise der DNA zu informieren. Leider hab ich kaum etwas verstanden. Vielleicht kannst du uns mal kurz erklären, wie du es verstanden hast?
Die Desoxyribonukleinsäure (Des|oxy|ribo|nukle|in|säure; kurz DNA oder DNS) (lat.-fr.-gr. Kunstwort) ist ein in allen Lebewesen und DNA-Viren vorkommendes Biomolekül und die Trägerin der Erbinformation. Sie enthält unter anderem die Gene, die für Ribonukleinsäuren (RNA, im Deutschen auch RNS) und Proteine codieren, welche für die biologische Entwicklung eines Organismus und den Stoffwechsel in der Zelle notwendig sind. Im allgemeinen Sprachgebrauch wird die Desoxyribonukleinsäure überwiegend mit der englischen Abkürzung DNA (deoxyribonucleic acid) bezeichnet; die parallel bestehende deutsche Abkürzung DNS wird hingegen seltener verwendet und ist laut Duden „veraltend“.[1]
Das bedeutet ja lediglich das , was ich von anfang an gesagt habe , dass die DNA für die entwicklung des organismus (seine Eigenschaften und Zusammensetzung) und seinen Lebesnzyklus ist.
Im genetischen Code stehen jeweils drei Basen für eine bestimmte Aminosäure.
Dies entspricht dem von uns verwendeten Befehlssatz
In diesem Artikel ist die "Befehlsabfolge" noch einmal genau beschrieben. Zudem verwendet der Verfasser durchaus erkennbare programmatische Struckturen , die auf eine übersetzungsmöglichkeit in die IT-Welt mögliche Abfolgen darlegen.
Ich stütze mich unter anderem auf diesen Artikel , wenn ich auch weiterhin meinen Standpunkt vertrete!
In der Natur haben doch die Basenpaare nicht die Bedeutung eines OP-Codes. Es ist doch alles andere als naturgetreu, die Basenpaare als OP-Codes zu interpretieren. Das ist m.E. nicht minder willkürlich und nicht weniger vom natürlichen Vorbild entfernt, als wenn man ein Bakterium tatsächlich als C#-Klasse definieren würde.
Das ist so nicht richtig!
In der natur dienen die Basenpaare als Ablaufprogramm für die organismusentwicklung bzw. die Lebensfunktionen.
In der DNA ist definiert , wie sich der Organismus vom Anfang seines Lebens bis zum Ende entwickelt und verhält.
Der Beste beweis ist die Pupertät. Die Menschliche Pupertät ist in Ihrem ablauf ebenfalls in der DNA verankert , genauso , wie die Haarfarbe etc.
Manche Forscher sprechen sogar von einem genetischen Gedächtniss , welches in einem Experiment mit Plattwürmern bewiesen wurde.
Ich gebe dir aber in sofern Recht , dass die DNA keinesfalls mit einem OP verglichen werden kann , ABER!! auch nur , weil es momentan und höchst vermutlich auch noch in ein Paar Jahren unerforscht sein bzw. bleiben wird!
Aber was ist dein Programm? Ein wissenschaftliches Projekt? Ein spielerisches Lernprogramm? Ein Spiel?
Wie ich bereits oben drüber gesagt habe , ist die DNA bisweilen noch unerforscht. Also ist es eher eine theoretische Form der richtigen DNA.
Das Auslesen beschränkt sich auf die Änderung von Werten in der Zelle selbst , bzw. auf die verwendung von Funktionen (um das ganze noch etwas einfacher zu gestalten).
Wobei hierbei der Stack ,die Register und die Funktionen der chemisch biologischen Prozesse der Zelle entsprechen.
Im grunde hängt es davon ab , welche Fähigkeiten du deinem Lebewesen gibst.
Doch! In einer Späteren Fassung werden wir auch versuchen , es so hinzubekommen , dass wir kleienr Wirbeltiere erschafen können.
Allerdings ist es ein langerweg von den relativ einfachen Microorganismen zu komplexeren Lebewesen. Es bedarf auch ein paar weiterentwicklungen der Klasse Cell und der CellCollection , die später das Lebewesen definieren wird.
Das Projekt ist vorwiegend Wissenschaftlich , wir wollten es jedoch zur generierung von Spielgegner benutzen.
Wir haben auch Fachkundige Hilfe von einem MTLA
Ohne gescheites Tutorial wird das wohl eher nichts werden, da mir dein kleines Beispiel oben z.B. überhaupt nicht weiterhilft zu verstehen wie ich da eine Lebensform programmieren könnte.
Anfangen musst du erstmal mit einem simplen Einzeller.
Bei dem musst du dir überlegen , in welchem Lebensraum es sich befinden soll , dann , von was es sich ernähren soll (z.b. durch Photosynthese)
Und entsprechende Programmabläufe implementieren.
Dann musst du sprungmarken für z.b. das Wachstum definieren und die Eigenschaften deienes Lebewesens festlegen.
Klingt einfach , ist aber je nach komplexität mit viel Arbeit verbunden.
Zudem müssen je nach Lebewesengruppe der Zelle noch Eigenschaften und Funktionen hinzugefügt werden , da sich Pilze ganz anders Verhalten wie Pflanzen.
Das kommt aber noch und so große Änderungen werden es durch die Komplexität der Grundklasse auch nicht sein.
Alles in allem wird sich die Engine dann aus 2 Gruppen jeder Lebewesengruppe zusammensetzen , der genetisch Programmierbaren und der Statischen (z.b. für ganz einfache Simulationen)
Zu dem haben wir noch eine ChemieEngine und eine EnvriomentEngine in Arbeit , um das gnaze noch Naturgetreuer zu gestalten.
Wenn ich Zeit finde , poste ich mal ein einfaches Beispiel für eine Alge.
Wenn es in C# zu schreiben sein soll , brauch ich auch nicht am Vorbild der Natur zu arbeiten , sondern kann direckt sagen "Das ist jetzt ein Bakterium , das kann dies und das und dammit schluss".
Da wir aber naturgetreu arbeiten wollen ist es nunmal drin und
es hat durchaus seine Dahseinsberechtigung , auch wenn der nutzen nicht klar zu sein scheint
Auch wenn es mit sicheheit auf ablehnung stßt , es gibtz auch heute noch n haufen leute , die in Assembler programmieren.
Erinnert mich an das Programmieren in Maschinensprache. Also nicht in Assembler, das ist ja noch halbwegs lesbar, sondern wirklich in Maschinensprache, also in Hexcodes des Prozessors. Liege ich da richtig?
Im Grunde ja, da die Opperationen auf Bytebene verlaufen , jedoch ist die Klartextstrucktur durchaus lesbar oder nicht?
Ne , is mir klar, da ich noch nicht die Zeit hatte ein Tutorial zu schreiben (und es anscheinend auch niemanden zu interessieren scheint)
Im Grunde besteht jeder Befehl aus zwei Basenpaaren.
Die Basenpaare bilden 16 kombinationen , von denen 7 als Befehl und der Rest als Modifier benutz werden.
Es gibt Sprungmarken , wie auch ein Jump
Darüberhinaus gibt es Register und Stackaddressierung und Modifizierer.
Das ganze wird mit Bedingungen abgerundet.
Ein Beispiel:
Plaintext
[]<5
[]>[0]
Genetisch
gaatcggg
gaattagaaaat
legt den Wert 5 auf den Stack und verschiebt ihn anschließend in das Register 0
Die Register beinhalten in der Regel ein Datenfeld mit den aktuellen Eigenschaften der Zelle , wie etwa die Lebenserwartung.
Die Geneik kann diese Werte verändern, bzw. mit ihnen arbeiten/rechnen , was die Eigenschaften der Zelle vrändert.
Darüberhinaus sucht die Zellklasse für die Methoden wie Pulse (ein Lebenszyklus ist vorbei) die entsprechende Sprungmarke in der DNA und wenn nach ausführung keine 0 auf dem Stack liegt , hat die DNA alles übernomen , sonst werden die normalen Operationen (die statisch festgelegt sind) ausgeführt.
Ausserdem kann die DNA auf Funktionen de Zelle zugreifen , so kann etwa mit dem Befehl
-> 2
aaat
Auf die Sensorik der Zelle zugegriffen werden , die (in der Standardversion der Klasse) , die chemische Signatur der umgebung als Datenfeld auf den Stack legt.
Alles in allem , kann über die Genetik alles im Bezug auf die Lebensform gesteuert werden.
Moin,
da wir ja mit unserer BIOEngine (BIOEngine züchten statt rendern [Version 19.02]) ziemlich gut voran kommen , dachte ich mir , es Black & White oder Spore einfach mal gleich zu tun.
Ob Göttersimulation oder Evolutionsspiel sind ja der Renner gewesen. Ich behaupte nur aus dem einen aber durchaus berechtigten Grund , dass man selbst als Spieler die Welt gestalten bzw. modifizieren kann, statt nur in eine fertige Welt mit festen Regeln geworfen zu werden.
Das ist meienr Meinung nach übrigens das Erfolgsrezept für gute Spiele , Individualismus. (Lässt sich natürlich drüber streiten)
Mir geht es in diesem Post darum , einen Wettbewerb zu veranstalten.
Jeder darf mitmachen!
Es geht in erster Linie darum , eine völlig frei gestaltbare Welt zu formen.
Die Teilnehmer können/dürfen über mehrere Runden ein Lebewesen gestalten , welches in jeder Runde entweder verbessert , gleichbelassen oder ausgestorben werden darf.
Es wäre wünschenswert , wenn ihr das genetische Programm für eure Lebensform in GCode , sprich also DNA schreiben würdet, da ich überlege als Privatprojekt auf unserem Server einen virtuellen Lebensraum mit Webinterface für die Lebensformen anzubieten.
Eine Simulation wäre dann mit der BIOEngine möglich.
Die Regeln sind folgendermaßen aufgestellt:*Es muss mit einem einzelligen Organismus begonnen werden *Das Produkt sollte einigermaßen realistisch sein (sprich keine überwesen ...) *es darf ausschließlich die Klasse Cell oder (eigene) Ableitungen verwendet werden *Es muss nicht in Basenpaaren gecodet werden (Plaintext ist durchaus erlaubt)
Die Lebewesen werden dann von den Forenmitgliedern bewertet und ein gewinner gekürt.
Bewertet wird in folgenden Kategorien:*Kreativität *Aussehen *Umsetzung *Realismus *Überlebensfähigkeit
Ausserdem wäre ich dafür , wenn die Teilnehmer über einen Name für die jeweilige Schöpfung abstimmen können.
Ich werde selbstverständlich Dokumentationen , eine komplette Codebeschreibung und einen Editor für Plaintext zur verfügung stellen.
Es würde mich allerdings ersteinmal interessieren , was ihr davon haltet bzw. wer überhaupt mitmachen würde.
Wir haben leider erst seit gut einem halben Monat einen Testserver, daher immernoch in der Testphase
Die aktuelle Version der BIOEngine implementiert nun vollständig die Sprache GCode!
Die Programme sind aufgebaut wie Assembler , jedoch schn etwas fortschrittlicher.
Es gibt einen Stack , der für die Zelle sowie für sämtliche Helixeinheiten der DNA sichtbar ist. Der Stack stell Botenstoffe der Zellen dar.
Darüberhinaus gibt es Register , ebenfalls für die Zelle und Helix sichtbar sind. Die addressierung erfolgt dynamisch , d.h. je nach bedarf werden Register angelegt.
Die genetische Programmierung besitzt Sprungbefehle , umfangreiche opeerationen , um auf dem Stack oder Registern zu arbeiten , Verzweigungen , Rechenopperationen und ist in der lage aus diesem Befehslssatz einzelne Elemente , wie etwa eine Schleife zusammenzusetzen.
Ebenfalls gibt es die Möglichkeit aus dem Programm heraus auf eigene Methoden der Zelle zuzugreifen.
Die Register der Zelle werden in der nächsten Version der BIOEngine mit den informationen der Zelle vorbelegt sein. Hierbei werden das alle Informationen der Zelle (Lebensenergiebedarf,Alter ...) und deren momentane DNA sein.
Es gibt keine längenbeschränkung der DNA , lediglich eine beschränkung auf 15 Helixeinheiten. (Jede Helixeinheit ist eine DNA-Sequenz)
Im Anhang ein kleiens Beispiel
Die aktuelle Version umfast schon eine implementierung von GCode. Diese ist allerdings längst noch nicht vollständig.
GCode wird aus jeweils 2 Basenpaaren pro befehl gebildet.
Auf Wunsch kann ich ein Tutorial in der Tutorial-Rubrik des Forums einstellen.
Die aktuelle Version umfasst schon einige Einzellermodelle , im ganzen aber erstmal nur Protozoa.
Protozoa versorgt , sofern genügen Licht vorhanden ist , sich selbst durch Photosynthese.
Weiter Einzeller und bald auch Mehrzeller sind geplant , ausserdem implementieren wir auch eine Form der Genetik.
Dies wird wie bei der DNA/DNS eine Anweisungsfolge für den Organismus sein , etwa im Punkt Wachstum oder Reproduktion.
Dabei werden die "Programme" mit Kombinationen aus Basen aufgebaut. So könnte eine Programmstrucktur etwa so wie im Anhang aussehen. Es ist auch ein Testprojekt in Planung , bei dem ein Programm als Organismus ausschließlich über GCode (Genetic Code) programmiert wird.
Wie bereits oben dargestellt , handelt es sich um eine Zellsimulation etwa von Schimmelpilzen oder Bakterien.
Man stellt einen Lebenszyklus und eine Vermehrungsrate für den Zellstamm ein und gibt der Kultur einen Nährboden. Anschließend wird die Vermehrung grafisch dargestellt.
Blau: Alles OK
Rot: Die Zelle stirbt im nächsten Zyklus (an Altersschwäche)
Grün: Es ist eine mutierte Zelle
Schwarz: Die Zelle ist tod
Es dient wie erwähnt als einfachste darstellung des Zellwachstums!!
Moin,
hierbei handelt es sich um ein Spassprojekt , welches sich BIOEngine nennt. Das Prinzip ist ganz einfach, man Programmiert auf grundlage von Biologischen abläufen wie etwa Zellebene.
Wir haben vor dammit in späterer Ausbaustufe z.b. aus einem Zellhaufen Gegner für ein Spiel zu "züchten". Auch ließe sich das Prinzip des Organismus auf ein Programm übertragen , bei dem statt Zellen der Quellcode wächst und sich selbst Selektiert.
Anbei ein kleines Beispielprojekt , eine Wachstumsimulation. Diese Simulation beruht auf dem einfachsten biologischen Modell: der Zelle.
Die Zelle lebt solange genug Nahrung(Energie) vorhanden ist , teilt sich , wenn die Energie dazu ausreicht und Stirbt ab , falls sie Aufgebraucht oder ihr maximales Alter erreicht hat.
Wenn die Zelle allerdings zuviel Energie zur verfügung hat , Mutiert sie und stirbt in der Regel oder auch nicht , in diesem Fall wird die Zellreproduktion unkontrolliert und die neuen Zellen können ebenfalls von anfang an mutieren.
Wir werden demnächst sehr intensiv an diesem Thema forschen und unsere erkenntnisse in die BIOEngine einbringen.
Die engine ist erstmal zur freien Verfügung , später aber nur für Freeware-Projekte zu haben!
Neueste Version Siehe letzter Post
Könnte es möglich sein , dass der Job dannach beended wird?
Wenn das der Fall ist , passiert es (zumnindest bei Threadbezogenen deklarationen) dass das Objekt danach nicht mehr Existiert. Ich vermute mal ganz stark , dass das Handle fehlerhaft ist.
Schon mal versucht ein BeginInvoke statt dem Invoke auszuführen?
Das kann in vielen Fällen helfen
Moin,
ich möchte hier gerne unseren ScriptWebService vorstellen. Es handlet sich dabei um eine Anwendung , die es ermöglicht CS2-Scripte per HTTP an beliebige Clients zu senden.
Der Service arbeitet dabei ähnlich einem Webserver , sommit können z.b. auch HTML-Dateien übertragen werden.
Das Hauptaugenmerk liegt allerdings bei CS2!
Es können Rechte vür die einzelnen Ordner vergeben werden , sowie Tickets , um bestimmten IPs den Zugriff auf bsp. weise vertrauliche Daten zu gewähren.
Der Service gewährt allerdings nur Zugriff auf die Ordner des Service , wodurch Datenklau verhindert wird. Das Programm wird bereits für unsere Webseite ausgiebig getestet und läuft auch nahezu Fehlerfrei.
Das Assambly des Servers enthalt in der Kalsse MainForm statische Methoden um z.b. per Script ein Ticket für den CGI-Ordner anzulegen.
Ausserdem ist der Server voll ClickOnce tauglich!
Zum weiterlesen
CSIPL
Zum anschauenUniverse-Community.de
Oder du meitest dir nen Server im Web und knallst es darauf
Ich habs jetzt ohne deine Tipps und mit 4 Stunden rumgebastel auf 38 ms (bei einem sehr langsamen rechenr) bei 25 Objekten gebracht. Auf meinem Tisch liegt das dann etwa bei 20 ms. Dennoch hängt das immernoch etwas von der Anzahl und Größe der Objekte ab.
Ich betrachte es trotzdem mal als gelöst!
Zumindest der Algorithmus schafft jetzt 0 ms(in sehr seltenen fällen etwa bei jedem 300ten durchlauf 2 ms)
Die tBitmap ist lediglich ne bitmap mit gemarschaltem aufruf von getpixel
ja neh , tu ich ja
bzw ich errechne ein Rechteck aus den Punkten
nichts desto trotz brauch der Aufruf von FloodFill(...) 16 ms pro Objekt
Mein FloodFill-Algorithmus ist zu langsam. Er braucht etwa 16 ms pro objekt.
Wie kann ich das Beschleunigen?
//b ist ein Bitmapobjekt
tbmp = new TBitmap(b);
for (int i = 0; i < tbmp.Width; i += 6)
for (int j = 0; j < tbmp.Height; j += 3)
{
bool bo = false;
for(int s = 0; s < rects.Count;s++)
if (i >= rects[s].X && i <= rects[s].X + rects[s].Width && j >= rects[s].Y && j <= rects[s].Y + rects[s].Height)
{
bo = true;
break;
}
if (bo)
continue;
Color c = tbmp.GetPixel(i, j);
if (c.B >= 200 && c.G >= 200 && c.R >= 200)
{
fa.FloodFill(b, new Point(i, j));
if (!rects.Contains(fa.Rect))
rects.Add(fa.Rect);
}
}
tbmp.Dispose();
//Anhand des CodeProjekt-Posts erstellt
public void FloodFill(Bitmap bmp, Point pt)
{
xCord = -1;
yCord = -1;
heigth = 0;
width = 0;
//get the bits
BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
System.IntPtr Scan0 = bmpData.Scan0;
int stride = bmpData.Stride;
unsafe
{
//resolve pointer
byte* scan0 = (byte*)(void*)Scan0;
//get the starting color
//[loc += Y offset + X offset]
int loc = CoordsToIndex(pt.X, pt.Y, bmpData.Stride);//((bmpData.Stride*(pt.Y-1))+(pt.X*4));
int color = *((int*)(scan0 + loc));
//create the array of bools that indicates whether each pixel
//has been checked. (Should be bitfield, but C# doesn't support bitfields.)
PixelsChecked = new bool[bmpData.Width + 1, bmpData.Height + 1];
//do the first call to the loop
LinearFloodFill4(scan0, pt.X, pt.Y, new Size(bmpData.Width, bmpData.Height), bmpData.Stride, (byte*)&color);
}
bmp.UnlockBits(bmpData);
}
unsafe void LinearFloodFill4(byte* scan0, int x, int y, Size bmpsize, int stride, byte* startcolor)
{
int yRLoc = 0;
int yLLoc = 0;
//offset the pointer to the point passed in
int* p = (int*)(scan0 + (CoordsToIndex(x, y, stride)));
//FIND LEFT EDGE OF COLOR AREA
int LFillLoc = x; //the location to check/fill on the left
int* ptr = p; //the pointer to the current location
while (true)
{
if (x - yLLoc < xCord || xCord == -1)
xCord = x - yLLoc;
if (x - xCord > width)
width = x - xCord;
PixelsChecked[LFillLoc, y] = true;
LFillLoc--; //de-increment counter
ptr -= 1; //de-increment pointer
yLLoc++;
if (LFillLoc <= 0 || !CheckPixel((byte*)ptr, startcolor) || (PixelsChecked[LFillLoc, y]))
break; //exit loop if we're at edge of bitmap or color area
}
LFillLoc++;
//FIND RIGHT EDGE OF COLOR AREA
int RFillLoc = x; //the location to check/fill on the left
ptr = p;
while (true)
{
if ((x + yRLoc) - xCord > width)
width = (x + yRLoc) - xCord;
PixelsChecked[RFillLoc, y] = true;
RFillLoc++; //increment counter
ptr += 1; //increment pointer
yRLoc++;
if (RFillLoc >= bmpsize.Width || !CheckPixel((byte*)ptr, startcolor) || (PixelsChecked[RFillLoc, y]))
break; //exit loop if we're at edge of bitmap or color area
}
RFillLoc--;
//START THE LOOP UPWARDS AND DOWNWARDS
ptr = (int*)(scan0 + CoordsToIndex(LFillLoc, y, stride));
for (int i = LFillLoc; i <= RFillLoc; i++)
{
//START LOOP UPWARDS
//if we're not above the top of the bitmap and the pixel above this one is within the color tolerance
if (y > 0 && CheckPixel((byte*)(scan0 + CoordsToIndex(i, y - 1, stride)), startcolor) && (!(PixelsChecked[i, y - 1])))
{
if (yCord == -1)
yCord = y;
else
yCord--;
LinearFloodFill4(scan0, i, y - 1, bmpsize, stride, startcolor);
heigth++;
}
//START LOOP DOWNWARDS
if (y < (bmpsize.Height - 1) && CheckPixel((byte*)(scan0 + CoordsToIndex(i, y + 1, stride)), startcolor) && (!(PixelsChecked[i, y + 1])))
{
LinearFloodFill4(scan0, i, y + 1, bmpsize, stride, startcolor);
heigth++;
}
ptr += 1;
}
}
unsafe bool CheckPixel(byte* px, byte* startcolor)
{
bool ret = true;
for (byte i = 0; i < 3; i++)
ret &= (px[i] >= (startcolor[i] - m_Tolerance[i])) && /**/px[i] <= (startcolor[i] + m_Tolerance[i]);
return ret;
}
Der alg war ursprünglich zum umfärben , ich benötige ja aber nur ein Rect mit dem Umfang des Objektes.
Zählerschleifen verwende ich ja , allerdings geschachtelt für die X und Y Koordianten.
Ich vermute aber gerade , dass das an der Rückgabe der Punkte , die durchlaufen werden Liegt. Das können ja immerhin ne ganze Ecke an Pixelkoordinaten sein. Das Lager ich aus und berechne stattdessen sofort ein Rectangle.
Ich habs bisher so gemacht , dass mir der Algorithmus die Pixel Färbt und dann weiterzält , ich änder das jetzt so um , dass ich kontrolliere , ob das Pixel im Rect liegt.
Ja , 2 - 3 ms währe Traumhaft 😁
Moin,
ich habe einen Algorithmus entwickelt , der ein 1024x768 Kammerabild auf Pixel prüft die heller sind als 199 RGB.
Das soll ein Algorithmus sein , um bei einem Multitouchtable die Berührungspunkte festzustellen. Das Programm braucht je nach Anzahl der Objekte
*0 Objekte 10 ms (leere Fläche)
*1 Objekt 15 ms (1 Finger)
*5 Objekte 60 ms (5 Finfer/ 1 Hand)
*bis 25 Objekte 160 ms (25 Finger / 5 Hände / 3 Personen)
Kommt auch auf die Größe der Objekte an , aber 160 ist das Langsamste , was ich bisher hatte 🤔
Meine Frage nun , Reicht das an Geschwindigkeit um annähernd an eine Maus heranzukommen oder ist das selbst für einen MTT immernoch zu langsam?
Ich verwende einen (von CodeProjekt nachgebauten) FloodFillAlgorithmus und eine unsafe BitmapKlasse zum schnellen Zugriff auf die Pixel.
Hast du die Kammeraposition richtig gesetzt?
Wenn du zu nah am Objekt bist , kann es sein , dass dieses den ganzen Bildschirm ausfüllt.
Ist deine Textur richtig geladen worden?
Wenn dies nicht der Fall ist , bleibt dein Objekt eben weiß.
Wie wärs mit einer OpenGL-Lösung?
Dammit kannst du eine Quadstrip oder Trianglestrip aus eienr Textur erstellen und "Animieren". Auch Transparenz wäre so machbar.
Dieses "Spiel" ist die Ideale Basis um auf Grundlage von OpenGL eine Kreaturen-Mutationsengine (a la Resident Evil) zu entwicklen 😁
Danke an den vb-man
Na gut , du wirst das wohl bsser wissen als ich. Ich habs dann wohl falsch gelesen.
Dann teste ich das Morgen mal aus und lasse mir mal n Log ausgeben.
Wenn das alles ist , dann klappt das ja sicher mit dem Elefanten 😁
Freut mich zu hören. Dein Durchhaltevermögen und Initiative ist beeindruckend 👍
Die grundsätzliche Reihenfolge ist1.glCreateShader 1.glShaderSource 1.glCompileShader 1.glCreateProgram 1.glAttachShader 1.glLinkProgram 1.glUseProgram 1.Falls der Shader Uniform-Variablen benutzt, können diese ab jetzt gesetzt werden. Dazu holle dir einen Handler mit glGetUniformLocation und mit glUniform* kannst du jetzt den Wert setzen.
Danke ersteinmal. Das ist auch was , was mich wirklich interessiert =)
Die obigen Punkte habe ich bereits mit meienr Shaderklasse abgedeckt und geteste. Was mir allerdings immernoch nicht ganz klar ist, wenn ich das von mir gepostete Beispiel verwenden möchte , wo und vorallem mit welchem Wert rufe ich dann die Attribute
varying vec3 position;
varying vec3 normal;
auf wenn ich ein Shema wie in meiner Meshklasse habe
... Matrix Puschen / Blending setzen / Textur verarbeiten / Transformationen ausführen
LibCore.Begi(BeginMode.Triangles);
for(int i = 0; i < points.Length / 3;i++)
{
Normalisieren[i,0]; //<< als Vector3[x,3] definiert
TexturKoordinate[0,1]; //<< als Vector3[x,3] definiert
Vector[i,0]; //<< als Vector3[x,3] definiert
Normalisieren[i,1]; //<< als Vector3[x,3] definiert
TexturKoordinate[0,1]; //<< als Vector3[x,3] definiert
Vector[i,1]; //<< als Vector3[x,3] definiert
Normalisieren[i,2]; //<< als Vector3[x,3] definiert
TexturKoordinate[0,1]; //<< als Vector3[x,3] definiert
Vector[i,2]; //<< als Vector3[x,3] definiert
}
LibCore.End();
... Blending aufräumen / Matrix Popen
entschuldige, das hätte ich beim ersten schreiben sollen.
Joah , macht nichts
Hier ist mein pupsender Elefant 😁
Die Shaderklasse funktioniert einwandfrei und auch die Extensions laufen wie geölt.
Ich übergebe zwar noch keine Werte (weil ich immernochnicht genau Weiß wo 🤔 ) aber zumindest das funktioniert schon.
Es war nicht CP , um das schonmal vorweg zu sagen.
Ich habe mir halt gedacht , dass , wenn man einen Shader erzeugt hat , man über die Instance eigenschaft diesem noch weiter Shader-Instanzen hinzufügen kann.
Ich habe dies nach durchgucken des Lighthouse-Tutoriums geschrieben.
Im DGL-Wiki habe ich die Beispielshader gefunden , die ich sehr gut finde und mal probieren möchte , alerdings weiss ich nicht , an welcher Stelle in meiner Routine die Aufrufe der Varialen gehören , wenn ich beispielsweise ein Polygonmesh aus [x,3] Vectoren zeichne und das jeweils über eine Triangleschleife.
Dazu noch Fragen:
Kann ich die intensität des Lichtes reglen, um z.b. eine Sonne darzustellen? (Wenn ja , wie?)
Kann ich die Lichtfarbe einstellen?
Hier mal meine klasse.
public class Shader : IDisposable
{
ShaderType type = ShaderType.FragmentShader;
public ShaderType Type
{
set { type = value; }
get { return type; }
}
string[] source = new string[0];
public string[] Source
{
set
{
source = value;
sourcelength = new int[value.Length];
for (int i = 0; i < value.Length; i++)
sourcelength[i] = value[i].Length;
}
get { return source; }
}
int[] sourcelength = new int[0];
public int[] SourceLength
{
get { return (int[])sourcelength.Clone(); }
}
uint shader;
public uint ParametricInstance
{
get { return shader; }
}
uint program;
public uint Instance
{
get { return program; }
}
bool used = false;
public bool Used
{
set
{
if (used)
return;
used = value;
if (value)
{
LibCore.UseProgram(program);
}
}
get { return used; }
}
public Shader()
{}
public Shader(string[] source)
{
this.Source = source;
ReCreate();
}
public Shader(string[] source, ShaderType type)
{
this.Source = source;
this.Type = type;
ReCreate();
}
public Shader(string[] source, ShaderType type, uint instance)
{
this.Source = source;
this.Type = type;
this.program = instance;
ReCreate();
}
public void Link()
{
LibCore.LinkProgram(program);
}
public void ReCreate()
{
shader = (uint)LibCore.CreateShader(type);
LibCore.ShaderSource(shader, source.Length, source, sourcelength);
LibCore.CompileShader(shader);
if (program == 0)
program = (uint)LibCore.CreateProgram();
LibCore.AttachShader(program, shader);
}
#region IDisposable Member
void IDisposable.Dispose()
{
LibCore.DeleteShader(shader);
LibCore.DeleteProgram(program);
}
#endregion
}
Was müsste ich denn jetzt tun wenn ich z.b. diese Shaderdaten verwenden möchte
varying vec3 position;
varying vec3 normal;
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_MultiTexCoord0;
normal = normalize(gl_NormalMatrix * gl_Normal);
position = vec3(gl_ModelViewMatrix * gl_Vertex);
}
uniform sampler2D Texture0;
uniform int ActiveLights;
varying vec3 position;
varying vec3 normal;
void main(void)
{
vec3 lightDir;
float attenFactor;
vec3 eyeDir = normalize(-position); // camera is at (0,0,0) in ModelView space
vec4 lightAmbientDiffuse = vec4(0.0,0.0,0.0,0.0);
vec4 lightSpecular = vec4(0.0,0.0,0.0,0.0);
// iterate all lights
for (int i=0; i<ActiveLights; ++i)
{
// attenuation and light direction
if (gl_LightSource[i].position.w != 0.0)
{
// positional light source
float dist = distance(gl_LightSource[i].position.xyz, position);
attenFactor = 1.0/( gl_LightSource[i].constantAttenuation +
gl_LightSource[i].linearAttenuation * dist +
gl_LightSource[i].quadraticAttenuation * dist * dist );
lightDir = normalize(gl_LightSource[i].position.xyz - position);
}
else
{
// directional light source
attenFactor = 1.0;
lightDir = gl_LightSource[i].position.xyz;
}
// ambient + diffuse
lightAmbientDiffuse += gl_FrontLightProduct[i].ambient*attenFactor;
lightAmbientDiffuse += gl_FrontLightProduct[i].diffuse * max(dot(normal, lightDir), 0.0) * attenFactor;
// specular
vec3 r = normalize(reflect(-lightDir, normal));
lightSpecular += gl_FrontLightProduct[i].specular *
pow(max(dot(r, eyeDir), 0.0), gl_FrontMaterial.shininess) *
attenFactor;
}
// compute final color
vec4 texColor = gl_Color * texture2D(Texture0, gl_TexCoord[0].xy);
gl_FragColor = texColor * (gl_FrontLightModelProduct.sceneColor + lightAmbientDiffuse) + lightSpecular;
float fog = (gl_Fog.end - gl_FogFragCoord) * gl_Fog.scale; // Intensität berechnen
fog = clamp(fog, 0.0, 1.0); // Beschneiden
gl_FragColor = mix(gl_Fog.color, gl_FragColor, fog); // Nebelfarbe einmischen
}
Wenn ich eine Polygonklasse habe , die jeweils 3 Vectoren in einem durchlauf rendert (Als BeginMode.Triangle)?
Nein , Shader sind mir Fremd 😁
ich habe OpenGL im Schnelldurchlauf gelernt und daraus gleich einen Wrapper für die wichtigsten Funktionen wie Meshes und Bitmaps erstellt.
Seit ich angefangen habe sind jetzt etwa 2 Wochen vergangen.
Das sieht schonmal ganz brauchbar aus, Danke!
Ich glaube ich werde GLSL ausprobieren.
Wobei mir der PixelShader am brauchbarsten aussieht oder habe ich unrecht?
[EDIT]
Habe hier auch was gefunden http://www.opentk.com/, da der Aufbau zumindest meines Kerns ähnlich ist , werde ich das mal probieren
Nachtrag: http://www.lighthouse3d.com/opengl/glsl/index.php?oglshader
Die lihtfunktion habe ich beim durcharbeiten der NeHE Tutorials , soweit da C# qeullcode vorhanden war schon gesehen , aber eben durch die Performanceverluste wieder verworfen 😁
Lightmaps würde ich durchaus auch im kleinen Rahmen verwenden wollen, aber über kurz oder lang möchte ich eben mit shadern arbeiten.
Wie funktioniert das ganze denn genau , da ich bei manchen Nehe-Werken eine extradatei mit shaderdaten gesehen habe. Das wäre ja , wenn ich das für jedes meienr 2000 Modelle machen würde ne ganze menge schreibkram 🤔
Moin,
kann mir eienr von euch sagen (bzw. anhand von Quellcode zeigen), wie ich in OpenGL meienr Scene viele Lichter hinzufügen kann und meinen Objekten sagen kann , dass sie Schatten werfen sollen?
Ich habe schon nach Lightmapping bzw Shader gegoogelt , aber leider keine brauchbaren C# ergebnisse gefunden. Und so C Versiert bin ich leider auch nicht 😦
Moin,
hierbei handelt es sich um ein auf der U3E-Bibliothek basierendes Programm , mit dem man ganz einfach Teile für Spiele bzw Ganze Spiele mittels CSIPL erstellen kann.
In der Version , die ich hier veröffentliche , gibt es bereits eine Texturverwaltung mit entsprechendem Vorschauframe , sowie eine Meshverwaltung mit Vorschau. Man kann auch bereits einzelne Meshes bearbeiten (z.b. mit Textur versehen). Das ganze ist noch sehr rudimentär , aber wir arbeiten drann 🙂
Es gelten wieder die in den Verweisen zu findenden Lizenzbedingungen.
[Verweise]
U3E Bibliothek
CSIPL
[Download]
http://www.file-upload.net/download-2054255/U3EDevellop.rar.html
**:::
Inklusive abgeschlossenem Samplebrowser.
Folgende Bugs sind gefixt.
*Enige Eigenschaften der Kamera sind vertauscht
*Die U3E.OpenGL.Drawing.Bitmap klasse verzerrt möglicherweise das gezeichnete Bild
*Fix der Device-Klasse
Mag sein , aber OpenGL ist insofern besser , da es weder ein installiertes Framework benötigt , noch nicht auf Grafikkarten inkompatibel ist.
Mein Laptop ist so alt , dass er noch ein Diskettenlaufwerk besitzt und darauf läuft OpenGL (insbesondere meine Bibliothek) , sehr performe , währen DirectX den Grafikchip nicht mal mit dem Arsch anschaut
Ich lade bei gelegenheit die Aktuelle Bibliothek hoch und den Samplebrowser a la NeHe.
Hat sich erledigt. Ich war immernoch im Texturmodus und er hat die Farbe von der Textur abgezogen. Habs gefixt.
Hier ist übrigens der Link http://www.koders.com/csharp/fidD686CDF3FF454A7F65A3276B3B1E5E52FBA50E86.aspx?s=zoom
OK , ich habs nach dem nehe Tutorial hinbekommen.
Ich zeichne meinen Text erfolgreich , jedoch , wenn sich dannach in der Scene was ändert , wird mein Fenster schwarz und es passiert garnichts mehr (auf der anzeige)
Weiß jemand woran das liegt?
Die sind meines Wissens nach aber nur über glut oder wgl realisierbar oder hast du ein Bespiel , wo das auch ohne (reines gl) klappt?
Moin,
weiss jemand , wie man lediglich mit OpenGL Funktionen , also ohne glut bzw wgl , einen Text auf einem GL-Screen aus gibt?
In DirectX gibt es ja auch die Möglichkeit GDI Elemente hinzuzufügen , so dass diese auf dem Schirm über der Scene zu sehen sind.
Gibt es sowas oder sowas ähnliches auch für GL?
Hier ein Programm um CustomMeshes zu erstellen. Die entsprechenden Laderoutinen sind in U3E.Data bereits implementiert.
Hilfreich wenn man mal eben einen 3D Hintergrund oder sowas erstellen will 😁
Und ich blind wien maulwurf , deshalb passet das schon 😄
Moin,
hier stelle ich euch unsere 3D Engine vor. Dabei handelt es sich um einen OpenGL-Wrapper und eine GDI Engine.
Dammit lassen sich schon sehr perfome , große Scenen darstellen. Ausserdem gibt es schon Effekte , wie Nebel und Textur/Alphatexturunterstützung.
Wir wären über Anregung und Kritik zur verbeseerung unserer Beta erfreut.
Verbesserungen werden auf jeden Fall noch gemacht.
[Edit 18.11]
Das aktuelle Bild zeigt den momentanen Stand.
Die Scene wurde mit dem OpenGL-Teil gerendert.
Die Performance lag dabei bei 1-2% Auslastung bei einer FPS-Rate von fast 200.
Es gelten diese Lizenzbedingungen
Treiber würde ich es nicht nennen , ich greife auf die Graka zu und übergebe der jedes Pixel einzeln (ja ich weiß , verdammt umständlich 😭 )
Die "virtuelle" Graka übergibt ein Array vom Typ Pixel an das Monitorcontrol und dieses zeichnet es auf eine Bitmap und gibt es als Bild aus (Ableitung einer Picturebox)
Habe gerade festgestellt , dass das Programm bei eienr bestimmten Assemblerbefehlsreihe abstürtzt , weshalb ich jetzt erstaml noch auf fehlersuche gehen muss X( Es ist ärgerlich aber da kann man nichts machen , ausser auf Fehlersuche zu gehen.
Ich hoffe , dass sich das bald findet.
[PS]
Habe mal für alle , die es interessiert einen Screenshot meines kleinen OS angehängt , quasi Werbung in eigener Sache 😁