Jammer-Thread

[Krishty]

Kann mir das jemand erklären?

    class Uncopyable {
    public:
        Uncopyable() { }
    private:
        Uncopyable(Uncopyable const &);
    };

    class ShouldntBeCopyable : public Uncopyable {
    public:
        explicit ShouldntBeCopyable(char const *) { }
        int foo() const { return 42; }
    };

    void test() {
        ShouldntBeCopyable instance("blah");
        ShouldntBeCopyable copy(instance); // Fehler – wie erwartet

        int x = (new ShouldntBeCopyable(ShouldntBeCopyable("")))->foo(); // Kompiliert – WTF?! Warum wird da kein Kopierk’tor aufgerufen?!

        int y = (new ShouldntBeCopyable(ShouldntBeCopyable(ShouldntBeCopyable(""))))->foo(); // JETZT ein Kopierk’toraufruf und ein Kompilierfehler
    }

Jetzt; Achtung; Achtung! Passt auf – Jetzt! Jetzt!


    class ShouldntBeCopyable { // Mal ohne Basisklasse
    public:
        explicit ShouldntBeCopyable(char const *) { }
        int foo() const { return 42; }
    private:
        ShouldntBeCopyable(ShouldntBeCopyable const &); // Jetzt is’er direkt drin!
    };

    void test() {
        int x = (new ShouldntBeCopyable(ShouldntBeCopyable("")))->foo(); // JETZT kommt auch hier ein Fehler …
    }

Ich verstehe new nicht. Die ganze Syntax ist sowas von in die Sprache geschissen, das gibt es garnicht.

[dot]

Hast du das auf verschiedenen Compilern getestet? Ich würd da jetzt mal auf Compilerbug tippen, evtl. in Zusammenhang mit Copy Elision...
Was genau ist denn das Problem mit new? :P

[Krishty]

Hast du das auf verschiedenen Compilern getestet? Ich würd da jetzt mal auf Compilerbug tippen, evtl. in Zusammenhang mit Copy Elision...

Nope; nur Visual C++ 2010.

Was genau ist denn das Problem mit new? :P

• Der Vorrang ((new foo)->bar(); statt new foo->bar();, obwohl kein Typname durch -> erreicht werden kann)
• Die Parametersyntax (operator new (sizeof(Type), b, c) ruft sich new (b, c) Type)
• Dass die Kontrolle über die tatsächliche Speichermenge dem Compiler übertragen wird (danke, dass doppelt Buch über die Allokationsgröße geführt wird; hätte ich nie selber hingekriegt! Klar; braucht man für die Anzahl der D’tordurchläufe in delete, aber darum auch …)
• Dass es kein Placement delete gibt („Objekte wissen selber am besten, wo sie herkommen.“ Fick diesen OOP-Scheiß! Ich muss sowieso irgendwie irgendwo Buch darüber führen, wie lang meine Arrays sind; also automatisier das vollständig (durch ein natives range-Muster) oder garnicht!)

[dot]

Die Parametersyntax (operator new (sizeof(Type), b, c) ruft sich new (b, c) Type)

Das ist nicht dasselbe. operator new ist etwas anderes als der new Operator und das Ergebnis dieser beiden Ausdrücke ist auch höchst unterschiedlich...

Dass die Kontrolle über die tatsächliche Speichermenge dem Compiler übertragen wird (danke, dass doppelt Buch über die Allokationsgröße geführt wird; hätte ich nie selber hingekriegt! Klar; braucht man für die Anzahl der D’tordurchläufe in delete, aber darum auch …)

Wer sollte denn sonst entscheiden, wie groß ein Objekt ist, wenn nicht der Compiler!?

[Krishty]

Die Parametersyntax (operator new (sizeof(Type), b, c) ruft sich new (b, c) Type)

Das ist nicht dasselbe. operator new ist etwas anderes als der new Operator und das Ergebnis dieser beiden Ausdrücke ist auch höchst unterschiedlich...

Siehst du? Bullshit.

Dass die Kontrolle über die tatsächliche Speichermenge dem Compiler übertragen wird (danke, dass doppelt Buch über die Allokationsgröße geführt wird; hätte ich nie selber hingekriegt! Klar; braucht man für die Anzahl der D’tordurchläufe in delete, aber darum auch …)

Wer sollte denn sonst entscheiden, wie groß ein Objekt ist, wenn nicht der Compiler!?

Entschuldige – wie groß ein Array ist. Das sollte der Compiler entweder komplett entscheiden (für alle Arrays), oder garnicht.

Bis dieses Jahr habe ich exklusiv Placement new eingesetzt, weil es die einzig konsistente Variation dieses Mechanismus ist. Ich weiß auch nicht, was mich geritten hat, jetzt wieder das normale new aufzurufen.

————

WTF, Microsoft Connect?! Wenn ich auf Anmelden klicke, werde ich angemeldet, ohne Nutzerdaten einzugeben. Ich kann dann alles upvoten und hastenichgesehen, aber keine Tickets erstellen. Wenn ich auf Registrieren klicke, steht da, dass jetzt die ganzen tollen Features (ignoriert werden; Bug-Reports für nichts schreiben; zusehen, dass alle schweren Fehler als by Design geschlossen werden) jetzt auch anderen zur Verfügung stehen sollen und man bei der Registrierung bloß seinen alten Anmeldenamen angeben soll, damit man den neuen Datenschutzbestimmungen zustimmt. Gebe ich ihn ein, sagt er: Nöööö, bereits vergeben!. WTF Microsoft, WTF

Hahaha stellt euch vor: Ich war im MSN Windows Live Messenger angemeldet. Als ich in Connect auf Anmelden geklickt habe, hat er auf die ID, mit der ich beim Messenger angemeldet war, ein Gastkonto angelegt. I can't even … wie sieht denn das aus, wenn mehrere Leute mit derselben IP surfen?! Haben die dann alle dieselbe Identität?! Wer SCHREIBT sowas?!

Oh, und: Wie ich das sehe, nehmen sie nur noch 2012 RC-Bugs entgegen.

[Chromanoid]

Ich glaube nicht, dass das via IP gemacht wird. Mit welchem Browser warst du denn unterwegs? Ich glaube da werden Cookies oder so gesetzt.

[Krishty]

Wie kann denn mein Messenger (Miranda) einen Cookie im Browser (Chrome) setzen? Zugegeben – Connect hat mir keine Live ID angezeigt, darum kann ich nur mutmaßen. Aber als ich mich ausgeloggt hatte und wieder einloggen wollte, stand im Live-ID-Eingabefeld bereits die ID, mit der ich privat chatte.

[Chromanoid]

ich schätze dann war es irgendein cookie von einer vorherigen anmeldung. sicher dass du dich in letzter zeit nicht irgendwann mal in irgendeinem windows live service angemeldet hast? also bei mir passiert da jedenfalls nichts in der richtung, ich meine mich gut zu erinnern, dass msn/windows live ziemlich lange sessions o.Ä. erlaubt. das ganze an der ip fest zu machen wäre wirklich irrsinnig, da die ja bei den wenigsten leuten fest ist und auch sonst verstecken sich ja meist mehrere rechner hinter einem router...

also bei mir loggt sich mein live account automatisch bei connect ein, wenn ich mich vorher irgendwo anders damit angemeldet habe. dienst konsolidierung nehme ich mal an. wahrscheinlich kannst du deinen connect account jetzt auch für den messenger benutzen, falls das nicht immer schon so war...

[Krishty]

Du hast recht – alle Cookies gelöscht; alle Sitzungen beendet; wieder im Messenger angemeldet; Connect aufgerufen und schon muss ich Live ID und Passwort eintippen (wie es sein sollte). Jetzt wüsste ich nur gern, wo diese Information heute vormittag herkam – ich lösche meine Kekse ziemlich oft; eigentlich allabendlich.

[dot]

Die Parametersyntax (operator new (sizeof(Type), b, c) ruft sich new (b, c) Type)

Das ist nicht dasselbe. operator new ist etwas anderes als der new Operator und das Ergebnis dieser beiden Ausdrücke ist auch höchst unterschiedlich...

Siehst du? Bullshit.

Also was genau jetzt dein Problem damit ist, erschließt sich mir immer noch nicht...

[Krishty]

Dass eine völlig inkonsistente Syntax ist, wo sich jemand dachte: Oh; es wäre cool, wenn man new int schreiben könnte und dann einen Zeiger auf ein frei allokiertes int bekäme!, und ihm später einfiel, Ups – jetzt muss ich aber irgendwo noch zusätzliche Parameter unterbringen, wenn ich von einem bestimmten Ort allokieren möchte … wo könnte ich denn jetzt noch Parameter unterbringen? Ah! Einfach zwischen die Wörter! und dabei dieses völlig bekloppte Geschwurbel rauskam, wo sie noch nicht einmal ordentliche Präzedenz reingekriegt haben.

new wie die Konvertierungsoperatoren anzulegen (also new<int>();) hätte es auch getan, und dabei nicht die Syntaxvorschriften ums Tausendfache verkompliziert. Das ist natürlich immernoch scheiße, denn da fehlt ja – OHMYGOD – auch noch sowas wie K’tor-Initialisierung für Arrays. Das ist sowieso der größte Faustfick; dass ich in C++ keine Möglichkeit habe, non-POD-Arrays bei der Konstruktion mit Parametern zu versorgen. Lass dir das mal auf der Zunge zergehen!

Und wegen dieser ganzen Scheiße ist new nur unter einer einzigen winzigen Bedingung produktiv einsetzbar: Einzelnes Placement new auf ein selber allokiertes char-Array in einer for-Schleife ganz unten drin in den Datencontainern. Und dann erwischt man einen Compiler, der da unzählige Nullprüfungen einführt (hier hätte jetzt ein Link zum Connect-Ticket sein sollen; aber irgendwie haben die für Visual Studio 2012 Connect geleert oder so), und sieht, dass man das durch Ändern des Placement new-Operators ändern könnte, aber natürlich nicht darf, weil in C++ die Sprache viel zu tief mit der STL verwurschtelt ist und es im Standard verboten wurde, einen anderen Operator Placment new zu definieren als den, der von deinem Compiler in <new> geliefert wird, weil, FICKT EUCH!.

[BeRsErKeR]

Krishty ich fänds toll wenn du mal eine Programmiersprache entwickelst oder daran beteiligt bist. Und das meine ich ironiefrei.

[Alexander Kornrumpf]

Yay und die compliliert dann zu Java-Bytecode.

[Krishty]

http://www.zfx.info/viewtopic.php?f=10& ... 285#p18296

Mangels Zeit hat sich im letzten Jahr nicht viel getan; ich bin etwa bei dem Punkt, wo der Compiler global Symbole zusammensuchen kann (also aufeinander verweisende Funktionen, Strukturen und Typnamen auflösen – von sowas wie Code Generation weit entfernt).

Schade eigentlich, denn es fühlt sich von allen meinen Projekten wie das einzig Sinnvolle an. Leider sind meine Ansprüche zu hoch um über eine ständige Analysis Paralysis hinauszukommen …

[BeRsErKeR]

Schade eigentlich. Ich bastel zur Zeit auch an ner Sprache. Vorwiegend aus Spaß an der Freude und wegen des Lerneffekts. Allerdings gehen mir auch viele Dinge auf den Sack (C, C++, Java, C# usw). Manche Sachen sind ja ganz toll, aber vieles ist einfach nur hingeschissen. Ich würd gern schon ein Konzept entwickeln, was nicht ganz katastrophal ist. Vielleicht kannst du mir ja ein paar Ideen/Kernpunkte für deine Sprache verraten (ein paar konnte ich ja deinem Link entnehmen).

Verblüffenderweise sieht deine Syntax für Funktionen fast exakt wie mein Entwurf aus. Bei mir soll es ein Modulsystem geben, bei dem die Reihenfolge ebenfalls keine Rolle spielt. Typen haben feste Größen (hab mich da teilweise an D orientiert, genau wie bei der Syntax von Arrays). Ich bin auch noch dabei vieles auszuklügeln, aber ich schätze mich nicht erfahren genug ein, um was Brauchbares auf die Beine zu stellen.

Bei mir steckt aber alles noch in den Kinderschuhen, sprich ich sitze noch am rohen Konzept für viele Dinge. Weit entfernt also von irgendeinem Codeschnipsel für einen Compiler.

Was mir auch wichtig ist, ist Nebenwirkungen so gut es geht zu minimieren. Bei mir sollen alle Funktionen von Haus aus "pur" sein, man kann also weder I/O durchführen, noch globale Variablen ändern. I/O-Funktionen müssen entsprechende gekennzeichnet werden und globale Variablen / statische Member soll es höchstwahrscheinlich gar nicht erst geben (allerdings globale Funktionen und eventuell statische Methoden, wobei mit global dann modul-lokal bzw. namespace-lokal gemeint ist).

Bei deinem Beispiel fällt mir das Schlüsselwort instance auf. Ich vermute du unterscheidest dadurch zwischen Stack und Heap? Dafür suche ich auch noch eine schöne Lösung.

[antisteo]

ich bin etwa bei dem Punkt, wo der Compiler global Symbole zusammensuchen kann

Damit hast du schon mal eine gute Wahl getroffen.
gwscript arbeitet auch mit globalen Definititonen, die erst mal zusammengesucht werden. Damit hast du erst mal Super-Highlevel aspektorientierte Programmierung.
Jetzt fehlt nur noch ein Paradigma, wie man die Low-Level-Sachen mit Zero Overhead hinbekommt.

[btw man könnte die Sprach-Sachen mal in nen extra Thread stecken]

[Krishty]

Verblüffenderweise sieht deine Syntax für Funktionen fast exakt wie mein Entwurf aus.

Ich habe lange versucht, eine einheitliche Deklarationssyntax sowohl für Daten als auch für Funktionen hinzukriegen, aber bisher mit wenig Erfolg.

Was mir auch wichtig ist, ist Nebenwirkungen so gut es geht zu minimieren. Bei mir sollen alle Funktionen von Haus aus "pur" sein, man kann also weder I/O durchführen, noch globale Variablen ändern.

Meinst du mit von Haus aus müssen pur sein oder sind pur so lange nicht anders angegeben? Keine Ahnung, ob Erstes so eine gute Idee ist – für eine Skriptsprache mit Sicherheit; für eine vollwertige Programmiersprache wäre es mir schon wieder zu utopisch. Pascal hat eine Unterscheidung zwischen Funktionen (Parameter zu Rückgabewert; letzterer muss vom Aufrufer behandelt werden) und Prozeduren (Wirkung; Rückgabewert optional); das wäre für mich ein brauchbarer Kompromiss.

hab mich da teilweise an D orientiert, genau wie bei der Syntax von Arrays

Array-Syntax ist ein interessantes Thema … ich hasse C(++)-Arrays. Im Augenblick löse ich in meinen C++-Projekten alles über range-Strukturen, die auf Anfang und Ende von Feldern zeigen, und das fließt wie Butter – abgesehen von dem winzigen Detail, dass der Compiler es nicht ausreichend optimiert, weil es keine Wurzel in der Sprache selber hat; und dass mir bei String-Literalen immer die automatisch angehängte Null zum Verhängnis wird (for teh luv of gawd, WHY!). Ich muss mir auch unbedingt nochmal Gos Slices ansehen, falls ich irgendwann mal Zeit habe. Und dann wären da noch Strings, die ja auch ein Thema für sich sind (Rein in die Sprache oder nicht? Nur Literale? Nullterminiert oder nicht? …).

globale Variablen / statische Member soll es höchstwahrscheinlich gar nicht erst geben (allerdings globale Funktionen und eventuell statische Methoden, wobei mit global dann modul-lokal bzw. namespace-lokal gemeint ist).

Gegen globale Variablen spricht für mich nur der eine Grund, dass sie nicht mit dem Konzept von Threads und Fibers vereinbar sind. Ich würde definitiv statische (vorberechnete) globale Variablen für sowas wie Nachschlagtabellen erlauben; wohl auch einige bei Programmstart initialisierte Instanzen (mit automatisch korrekter Initialisierungsreihenfolge, da ich die Abhängigkeiten sowieso zur Typauflösen ausklamüsern muss), weil man sich ohne einfach zu weit von der Praxis entfernen würde. (Beispiel Spiele-Sandbox: Wo nähmst du freien Speicher manueller Lebenszeit her, falls du weder I/O aufrufen, noch einen globalen Zeiger anlegen könntest? Du müsstest alles auf esoterische, wahrscheinlich halb rekursive Gebilde umschrauben … das würde es für den Compiler-Entwickler vereinfachen, aber sicher nicht für den Programmierer.) Aber bei mit dem Prozess initialisierten Variablen würden dann wieder Leute alles aushebeln, indem sie ihr ganzes Programm in einen K’tor packen (MFC).

Bei deinem Beispiel fällt mir das Schlüsselwort instance auf. Ich vermute du unterscheidest dadurch zwischen Stack und Heap?

Nein; das benötige ich für Template-Metaprogrammierung. Genau genommen benötigt C++ es (in Form von typename vor den Namen abhängiger Typen in Templates), um beim Parsen zwischen den Fällen
    a * i; // Multiplikation; a: int; i: int
    a * i; // Zeigerdeklaration; a: typedef für int; i: Name des Zeigers
unterscheiden zu können. Ich brauche es immer, weil ich ja keine Deklarationen habe und der Compiler sonst beim Parsen dieser Stelle nicht wissen könnte, um welchen der Fälle es sich handelt. Mit einer ausreichend klaren Deklarationssyntax wäre das am Ende sicher obsolet; aber um es mir selber zu vereinfachen, habe ich es erstmal dringelassen. Was die Unterscheidung zwischen Stack / Heap angeht (sehr unglückliche Begriffe; nennen wir sie automatische und manuelle Speicherverwaltung), würde ich nur eine Placement-Syntax bauen (d.h., Byte-Array aus beliebiger Quelle zu Objekt initialisieren) und die vor ein paar Tagen erwähnte Array-Initialisierung irgendwie reinboxen.

[Jonathan]

Ich versuche mittlerweile seit Wochen das Equalizer-Framework unter Windows zu kompilieren. Es geht einfach nicht. Heute habe ich schon 2 Bugs in den CMake-Skripten gefunden, aus denen offensichtlich wurde, das sich keine Sau für die Windowsversion interessiert, jedenfalls frag ich mich, wie man sie in diesem Zustand benutzen sollte.

Achja: Es gibt auch eine vorkompilierte Version, allerdings stürzt der Installer jedesmal ab, weil die Umgebungsvariable PATH zu lang ist, als das er sie verändern kann (äh, wie kann das denn sein), was ich allerdings im Fenster vorher explizit ausgeschaltet habe. Supi.

Oh, und VisualStudio hängt sich immer beim kompilieren auf und macht dann gar nichts mehr. Vielleicht hat das was mit diesen Fehlermeldungen zu tun, die offensichtlich daher kommen, dass er keine Leerzeichen in Pfaden mag (und das im Jahr 2012, das darf doch wohl nicht wahr sein).

Jetzt bin ich immerhin soweit, dass ich Linkerfehler habe, die ich nicht verstehe. CMake generiert mir da eine Projektmappe mit geschätzten 200 Unterprojekten, davon eine Lib in der eine Funktion ist, die eine andere benutzt, dann aber einfach nicht da ist. Ich habe mir diese Lib im kompilierten Zustand mal mit dumpbin angeschaut und die fraglichen Funktionen stehen tatsächlich nicht drin. Keine Ahnung, was ich da jetzt noch machen soll, vielleicht liegt es einfach daran, dass es die aktuelle Version aus dem git-Repo ist.

In so Momenten weiß man einfach, dass C++ auch nur Mist ist.

[BeRsErKeR]

Verblüffenderweise sieht deine Syntax für Funktionen fast exakt wie mein Entwurf aus.

Ich habe lange versucht, eine einheitliche Deklarationssyntax sowohl für Daten als auch für Funktionen hinzukriegen, aber bisher mit wenig Erfolg.

Ja ich bin auch noch am Frickeln.

Was mir auch wichtig ist, ist Nebenwirkungen so gut es geht zu minimieren. Bei mir sollen alle Funktionen von Haus aus "pur" sein, man kann also weder I/O durchführen, noch globale Variablen ändern.

Meinst du mit von Haus aus müssen pur sein oder sind pur so lange nicht anders angegeben? Keine Ahnung, ob Erstes so eine gute Idee ist – für eine Skriptsprache mit Sicherheit; für eine vollwertige Programmiersprache wäre es mir schon wieder zu utopisch. Pascal hat eine Unterscheidung zwischen Funktionen (Parameter zu Rückgabewert; letzterer muss vom Aufrufer behandelt werden) und Prozeduren (Wirkung; Rückgabewert optional); das wäre für mich ein brauchbarer Kompromiss.

Zur Zeit unterscheide ich zwischen Funktion und Prozedur. Da Prozeduren ohne Nebenwirkungen sinnfrei sind, müssen diese eigentlich nicht weiter mit Schlüsselwörtern beschmückt werden. Ich nutze aber zusätzlich noch ein Schlüsselwort um Funktionen als non-pure bzw. in dem konkreten Fall als Funktionen, die I/O durchführen zu kennzeichnen. Problematisch ist halt, wie du sagst, dass man dann eigentlich nicht wirklich I/O nutzen kann, weil pure Funktionen keine I/O-Funktionen aufrufen können. Und das ganze ab der main-Funktion trennen ist wohl auch nicht sehr sinnvoll oder in jedem Fall machbar. Und prinzipiell benötigt man auch nicht-pure Funktionen, falls man z.B. was aus ner Datei lesen will. Naja mit dem Thema werde ich mich noch beschäftigen.

hab mich da teilweise an D orientiert, genau wie bei der Syntax von Arrays

Array-Syntax ist ein interessantes Thema … ich hasse C(++)-Arrays. Im Augenblick löse ich in meinen C++-Projekten alles über range-Strukturen, die auf Anfang und Ende von Feldern zeigen, und das fließt wie Butter – abgesehen von dem winzigen Detail, dass der Compiler es nicht ausreichend optimiert, weil es keine Wurzel in der Sprache selber hat; und dass mir bei String-Literalen immer die automatisch angehängte Null zum Verhängnis wird (for teh luv of gawd, WHY!). Ich muss mir auch unbedingt nochmal Gos Slices ansehen, falls ich irgendwann mal Zeit habe. Und dann wären da noch Strings, die ja auch ein Thema für sich sind (Rein in die Sprache oder nicht? Nur Literale? Nullterminiert oder nicht? …).

Klingt interessant. Kannst du mir da mal ein Beispiel zeigen? Zwecks range-Strukturen.

Bei deinem Beispiel fällt mir das Schlüsselwort instance auf. Ich vermute du unterscheidest dadurch zwischen Stack und Heap?

Nein; das benötige ich für Template-Metaprogrammierung. Genau genommen benötigt C++ es (in Form von typename vor den Namen abhängiger Typen in Templates), um beim Parsen zwischen den Fällen
    a * i; // Multiplikation; a: int; i: int
    a * i; // Zeigerdeklaration; a: typedef für int; i: Name des Zeigers
unterscheiden zu können. Ich brauche es immer, weil ich ja keine Deklarationen habe und der Compiler sonst beim Parsen dieser Stelle nicht wissen könnte, um welchen der Fälle es sich handelt. Mit einer ausreichend klaren Deklarationssyntax wäre das am Ende sicher obsolet; aber um es mir selber zu vereinfachen, habe ich es erstmal dringelassen. Was die Unterscheidung zwischen Stack / Heap angeht (sehr unglückliche Begriffe; nennen wir sie automatische und manuelle Speicherverwaltung), würde ich nur eine Placement-Syntax bauen (d.h., Byte-Array aus beliebiger Quelle zu Objekt initialisieren) und die vor ein paar Tagen erwähnte Array-Initialisierung irgendwie reinboxen.

Ich möchte es bei mir recht strikt und eindeutig halten. Ich überlege z.B. die Ausdrücke für Typen und Variablen soweit einzuschränken, dass sie in jedem Fall unterscheidbar sind und auch die Syntax für Pointer wird eher in Richtung von pointer<a> i; gehen, als a * i; - halt um solche Sachen zu vermeiden. Aber auch da muss ich mir noch was Anständiges überlegen.

typedef/alias plane ich auch gänzlich wegzulassen oder wenigstens nur sehr begrenzt anzubieten. Ich bin eher für ein bischen mehr Schreibaufwand als für möglichst kurze Typnamen. Gleiches gilt für using namespace und so Sachen. Es führt letztlich eher zu Verwirrungen und kann auch zu solchen Uneindeutigkeiten führen, die du angesprochen hast.

[CodingCat]

HLSL Packing ...

Code: Alles auswählen

struct Bounds { float3 Min, Max; };
RWStructuredBuffer<Bounds> BoundsUAV;

struct BoundsConstantLayout
{
   float4 MinM;
   float2 ax;
};
cbuffer BoundsConstants
{
   BoundsConstantLayout BoundsConstants;
}

// ...

float3 min = BoundsConstants.MinM.xyz;
float3 max = float3(BoundsConstants.MinM.w, BoundsConstants.ax);

Das Beispiel ist natürlich vereinfacht. Will man einen RWStructuredBuffer einfach auf gleiches Layout mit einem Constant Buffer bringen, reicht manuelles Padding:

Code: Alles auswählen

struct Bounds { float3 Min; float _1; float3 Max; float _2; };
RWStructuredBuffer<Bounds> BoundsUAV;

cbuffer BoundsConstants
{
   Bounds BoundsConstants;
}

// ...

float3 min = BoundsConstants.Min;
float3 max = BoundsConstants.Max;

[TDK]

Was zum Jammern ist:

Wenn ich mir hier die Postings im Thema durchlese, frage ich mich mittlerweile, ob ich hier in einem Programmiersprachen-Guru-Forum gelandet bin, oder in einem Forum für Spieleprogrammierer :|

[Andre]

Was zum Jammern ist:

Wenn ich mir hier die Postings im Thema durchlese, frage ich mich mittlerweile, ob ich hier in einem Programmiersprachen-Guru-Forum gelandet bin, oder in einem Forum für Spieleprogrammierer :|

Das kann ich nur bestätigen :lol:

[j.klugmann]

Da programmiere ich seit Tagen an meiner Rendering-Monade herum und wunder mich warum beim Weiterreichen in die App-Monade nichts angezeigt wird. Da fehlte mir einfach im Bind-Operator der Flush-Aufruf...

*ggrrr*

[CodingCat]

DirectCompute ...

[dot]

Ich kann dich beruhigen: Mit OpenCL würd's vermutlich noch viel schlimmer aussehen ;)

[Chromanoid]

Ich kann mir gut vorstellen, dass das was du (CodingCat) machst nichts damit zu tun hat, aber was haltet ihr eigentlich von Sachen wie C++ AMP http://msdn.microsoft.com/en-us/library ... .110).aspx oder Aparapi http://code.google.com/p/aparapi/? Schon mal benutzt?

[dot]

Ich seh' in C++ AMP sehr viel Potential. Verwendet hab ich's aber noch nicht...

[eXile]

Ich habe es versucht zu verwenden (unter Visual Studio 2012 im Consumer Preview von Windows 8 mitsamt Parallel Nsight Debugging), bis ich plötzlich gemerkt habe, dass meine VM ja gar keine richtige Graphikkarte emuliert. :|

[eXile]

Wie Karlsruhe ist nicht mehr exzellent?



(Alleine dass Saarbrücken sich über das MPI was schnorren muss, zeigt, dass irgendwie in Deutschland was schiefläuft.)

[CodingCat]

Nein nein, das hat schon seine Richtigkeit, dank Java sind wir hier leider im Laufe des letzten Jahres kollektiv verblödet. (Ich habe gerade mehrere 100 Zeilen fremden Mathecode von abstrusem x.Cross(y) auf cross(x, y) gebracht, auch deshalb ist ADL ein Segen; hat aber nichts mit der Uni zu tun ...).

In other news: Entweder ich habe seit Tagen einen ultrafetten Bug in meinem Code, oder Ray Space Hierarchies sind nicht mal ansatzweise zu gebrauchen?!? :-/