Deutsch
PHP, HTML & JavaScript- Forum

3D Grafik - WebGL mit three.js

 
- Seite 1 -



HofK
Auf einen heißen Tipp von IF hin, habe ich mir mal
three.js  [...]  angeschaut. Da  [...]  (ganz unten) die ersten Resultate.
 
31.01.2016  
 



 
- Seite 41 -



HofK
RudiB. (26.02.2021)
Ist mir bereits auch so ergangen, man verliert einfach den Überblick.....



Da ist was dran!

Mit den Variablen der Zählschleifen verhält es sich aber tatsächlich so. In der for- Schleife sind sie lokal. Daher nimmt man im Programm immer wieder

for ( let i = 0 ...

und es gibt kein Durcheinander.

Den Überblick hatte ich aber bei der Division verloren. Meine Euphorie war wieder einmal zu groß.

Die reine Anzahl der notwendigen Wiederholungen ist nicht das Problem. Aber ich hatte übersehen, dass dabei noch ineinander verschachtelte Schleifen auftreten in denen dann wiederum Steps und Bitsteps sowie Addition notwendig sind.

Die Sache wird so komplex, dass sie mit der Methode wie bei der Multiplikation nicht zu bewältigen ist - wenn überhaupt.

Ich werde eine Notlösung mit jeweils kleinen "Kunstpausen" erstellen. Nach Tests mit sinnlosen Rechenschleifen kommt man da auf gut eine Sekunde die Browser akzeptieren.

Der aktuelle Stand  [...] 

Bei der Division muss man jedes mal passende Daten in die Register bringen. Das ist schon ein Miniprogramm und nervt, wenn man es zum Test ständig neu eingeben muss.

Also ist es Zeit, sich um das laden von Dateien zu kümmern. Dann kann man die Assemblerdateien per Klick laden und auch Varianten testen.

Im Netz findet man dazu nicht sehr viel, z. B.  [...]   [...] 
Die Beispielseiten haben das Problem, keine vollständige HTML Seite zu liefern. Es ist nicht ganz leicht, den Kern der Sache aus der komplexen Seite herauszuziehen.

Ist mir aber nach einigem fluchen über HTML/JS doch gelungen.

Hier der knappe Code, der alleine schon reicht und der auch lokal ausgeführt werden kann. Einfach kopieren und testen. Die asm Dateien sind in meinem Projekt vom Typ txt. Daher die Auswahl const textType = /text.*/;
<!DOCTYPE html>
<head>
<title> FileReader </title>
<meta charset="utf-8" />
</head>
<body>
<input type="file" id="asmLoad" style="visibility: hidden">
<label for="asmLoad" id="selectFile"></label>
<button id="load"> load </button>
<div id="content"></div>
</body>
<script>
const content = document.getElementById('content' );
load = document.getElementById('load' );
load.addEventListener('click', loadAsmFile );
const reader = new FileReader( );

function loadAsmFile( ) {

    selectFile.innerText ='select file';
    asmLoad.addEventListener('change', e =>

    {

        const file = asmLoad.files[0];
        const textType = /text.*/

        if ( file.type.match( textType ) ) {

            selectFile.innerText ='';
            reader.readAsText( file );
            reader.onload = e => content.innerText = reader.result;

    } else { content.innerText = "incorrect file type"; }

} );

}

</script>
</html>
 
09.03.2021  
 




HofK
Im Anfängerbeispiel gibt es jetzt im Schritt 2 Bienen. Eine Biene ist ein Klone der anderen. Im Schritt 4 jetzt ein Video als Textur. Das Video läuft nur in diesem Schritt, ansonsten sitzt der Vogel nur reglos da. Bei Firefox gibt es zuweilen Startschwierigkeiten, F5 hilft.

Im Schritt 13 bekommen die Bienen ihre Wabe. Sie ist mit InstancedMesh realisiert. Nur in diesem Schritt schließen und öffnen sich die Waben.

 
15.03.2021  
 




HofK
Bei der CPU-Simulation funktioniert nun das Laden von Assembler-Dateien.
function load_asm( ) {// HC680 Assembler-Datei laden (*.txt)

    ...

Unter  [...]  kann man zum Test einige Assemblerdateien finden und herunterladen. Die Programme laufen aber keineswegs fehlerfrei, da noch nicht alle Befehle überprüft und entsprechend korrigiert wurden. Das ist noch viel Detailarbeit und kostet Zeit.

Je mehr ich in sehr spezifische Dinge komme wird deutlich, dass Reengineering anspruchsvoller ist als eine Sache aus dem Stand zu programmieren.

Dabei habe ich ein Programm als Grundlage, dass ich vor Jahren selbst erstellt habe.

Das Problem ist, dass man sich gleichzeitig mit zwei sehr unterschiedlichen Umgebungen und Sprachen auseinandersetzen muss und man zusätzlich immer an der Vorlage klebt. Das wird zum Problem, wenn eine Sache sich in der anderen Umgebung überhaupt nicht in dieser Art und Weise umsetzen lässt.

Mein Divisionsproblem! 

Da verwundert es nicht, wenn man hört, dass einige Kernprogramme im Bankenwesen immer noch in COBOL laufen. Dafür gibt es kaum noch aktive Programmierer aus der alten Zeit, man hat bereits nachgeschult.
 
15.03.2021  
 




HofK
Zwischendurch mal wieder etwas anderes.

Die Verformung von grundlegenden Geometrien wie Rechteck und Cylinder ermöglicht interessante Formen.

Auf eine Frage hin  [...]  hat prisoner849 alias Paul West wieder einmal einen cleveren Lösungweg angeboten. Ist in der Sammlung  [...] 

Eine wesentlich einfachere Variante zur Veränderung der Positionen habe ich als Antwort auf eine andere Anfrage erstellt. Ein flach gedrückter Torus.  [...] 

 [...] 

Der Fisch von prisoner849 brachte mich auf die Idee der Verallgemeinerung.



Basis ist hier ein Zylinder. Als ich die Kappen hinzufügen wollte, bin ich auf ein Problem gestoßen. Die Mittelpunkte der Kreise sind mehrfach definiert. Auf eine Anfrage  [...]  gab es bisher keine Resonanz. Also habe ich statt des Zylinders wieder eine benutzerdefinierte Geometrie erzeugt. Diesmal aber als eigenständige BasicGeometry - abgeleitet von CylinderGeometry und stark reduziert.
function BasicGeometry( radialSegments, heightSegments, withTop, withBottom ) {

    let indices = [];
    let uvs = [];
    let index = 0;
    let indexArray = [];
    let groupStart = 0;
    let groupCount = 0;

    for ( let y = 0; y <= heightSegments; y ++ ) {

        let indexRow = [];
        let v = y / heightSegments;

        for ( let x = 0; x <= radialSegments; x ++ ) {

            uvs.push(  x / radialSegments, 1 - v );
            indexRow.push( index ++ );

        }

        indexArray.push( indexRow );

    }

    let a, b, c, d;

    for ( let i = 0; i < radialSegments; i ++ ) {

        for ( let j = 0; j < heightSegments; j ++ ) {

            a = indexArray[ j ][ i ];
            b = indexArray[ j + 1 ] [ i ];
            c = indexArray[ j + 1 ][ i + 1 ];
            d = indexArray[ j ] [ i + 1 ];
            indices.push( a, b, d );
            indices.push( b, c, d );
            groupCount += 6;

        }

    }

    g.addGroup( groupStart, groupCount, 0 );
    groupStart += groupCount;
    let verticesCount = ( radialSegments + 1 ) * ( heightSegments + 1 )

    if ( wTop ) generateCap( true );

        if ( wBtm ) generateCap( false );

            g.setIndex( new THREE.BufferAttribute( new Uint32Array( indices ), 1 ) );
            g.setAttribute('position', new THREE.BufferAttribute( new Float32Array( verticesCount * 3 ), 3 ) );
            g.setAttribute('uv', new THREE.BufferAttribute( new Float32Array( uvs ), 2 ) );

            function generateCap( top ) {

                let groupCount = 0;
                uvs.push( 0.5, 0.5 );
                const centerIndex = index;

                for ( let x = 0; x <= radialSegments; x ++ ) {

                    uvs.push( 0, 0 );
                    index ++;

                }

                index ++;

                for ( let x = 1; x <= radialSegments; x ++ ) {

                    const c = centerIndex;
                    const i = centerIndex + x;

                    if ( top ) {

                        indices.push( i, i + 1, c );// face top

                    } else {

                        indices.push( i + 1, i, c );// face bottom

                    }

                    groupCount += 3;

                }

                g.addGroup( groupStart, groupCount, top ? 1 : 2 );
                groupStart += groupCount;
                verticesCount += radialSegments + 2;// with center

            }

        }


Die Sache ist noch in Arbeit, aber es ergibt sehr vielfältige Formen.



So einfach definiert man die Form:
// 					   no  flat smooth
// ext string - with top:  x,  f,  s    | with bottom:  x,  f,  s | connected: x, c
const design = [
// max vert, ext, angle, 0 first, ... , max radial
[  40,"ffc",314,    0,  20,  36,  45  ],
// center x, y, z,  distance to center orthogonal-radial
[ 0.0,  0.4, 0.0,  1.0, 1.0, 0.8, 0.8 ],//  top, max vert.
[ 0.1,  0.0, 0.1,  1.2, 0.6, 0.6, 0.7 ],//  some centers x,y,z
[ 0.0, -2.0, 0.0,  0.3, 0.4, 0.3, 0.5 ],
[ 0.0, -3.0, 0.4,  0.6, 0.8, 0.7, 0.7 ],//  bottom
];
const geo = Curved2Geometry( design );



Hier müssen noch die uv Werte der Kappen berechnet werden.
 
25.03.2021  
 




HofK
Wenn man erst einmal den richtigen Ansatz gefunden hat, ist die Rechnug selbst kein Problem.
const u = 0.5 - pts[ 0 ][ j ].z / uMax / 2;
const v = 0.5 - pts[ 0 ][ j ].x / vMax / 2;
g.attributes.uv.setXY( idx, u, v );

Dabei enthält das Array pts für jede vertikale Schicht ([ 0 ] die obere) ein Array mit den auf die jeweilige im 3D Raum liegende Ebene bezogenen Koordinaten. Diese wurden zur Bestimmung aller Positionen vorher bereits berechnet. uMax bzw. vMax sind dabei die maximal aufgetretenen Werte in der oberen Schicht.

Für den Boden läuft es analog.

 
26.03.2021  
 




HofK
Wieder zurück zur CPU Simulation brachten einige Versuche mit der Addition in der ALU merkwürdige Ergebnisse. Das letzte Bit blieb teils leer und damit waren die Resultate natürlich falsch.

Nach vielen console.log( ) Ausgaben stellte ich fest, dass immer bei Bit 0 etwas schief lief. Die runde Null hat so öfters ihre "Ecken und Kanten".

Dann bekam ich heraus, dass ein Ergebnis-String der 9 Bit ALU eine Länge von 18 hatte. Auch bei Bit 0!

Also alle in diesem Zusammenhang benutzten Befehle und Funktionen unter die Lupe genommen. Dabei stieß ich auf right( s, n ).

Um den Quellcode vergleichbar zu halten und auch um die Übernahme von XProfan nach JavaScript überschaubar zu gestalten, habe ich wie weiter oben beschrieben, einige Funktionen von XProfan in JS nachgebildet.

So auch
const right = ( s, n ) => ( s.substr( -n ) );

Das mit -n findet man dort: [...] 

Im Test war es auch ok.

Was ich nicht bedacht und geprüft hatte, war die doch sehr spezielle Zahl 0, obwohl man das immer machen sollte.

Ich kann mich gut erinnern, das der Einstieg in die höherer Mathematik mit dem Beweis begann, dass es nur eine Null gibt. Erscheint dem "normalen" Menschen selbstverständlich und nicht der Rede wert. Gab seinerzeit auch erst großes Erstaunen was das soll. Hinterher war es klar - wie meist immer bei solchen Dingen. 


In der entsprechenden XProfan Schleife
R9$ =   space$(8-bit%) + r$  + right$(R9$, bit%)' ... als das Resultat-Bit
wird anfangs bit% Null.

Bei XProfan right$ kommt ein Leerstring wie gewünscht.
declare m$
m$ = "abcde"
print 0
print right$( m$, 0 )
print 1
print right$( m$, 1 )
WaitInput

Bei der JS right Funktion bedeutet aber -0 auch 0 und s.substr( 0 ) liefert den ganzen String. Der selbst ist zuerst mit Leerzeichen gefüllt. Dadurch versteckt er sich gut, nur die Länge 18 hat ihn verraten.

Man muss die 0 "behandeln".
const right = ( s, n ) => ( n === 0  ?''  :  s.substr( -n ) );

Ich bin mir sicher, das war nicht der letzte Stolperstein (oder doch -felsen?) bei der Portierung.

 
01.04.2021  
 




p.specht
Immerhin könntest du den Stolperstein nun in 3D modelieren
 
XProfan 11
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen...
01.04.2021  
 




HofK
Der nächste Stolperstein war die zeitlich unbegrenzte Unterbrechung des Programmlaufs über den Startknopf. Nach einigen Fehlversuchen und ein wenig Umgruppierung im Code konnte ich das aber durch einer einfache Zeitangabe verwirklichen. Der Takt wird unendlich ausgedehnt.

Eine weitere Etappe ist damit geschafft. Das erste Testprogramm ist voll funktionstüchtig. Es ist mehrfach startbar.

Man kann Zahlen eingeben, zwischendurch pausieren und den Takt mit dem Schieberegler verändern. Die Summe erscheint im I/O-Protocol.

Dort ausprobieren:  [...] 

Die Assemblerdatei lokal speichern. Dort zu finden.  [...] 

Und hier:
 
vor 31 Tagen  
 




HofK
Der Fisch entwickelt sich.

Problem ist es, eine passende Textur zu basteln. Dazu muss man ein Foto entsprechend verzerren.

Eine Anfrage auf discourse  [...]  hatte keine Resonanz, aber zufällig war in einem anderen Beitrag  [...]  ein Link, der das Problem löst.  [...] 

Zwar nicht perfekt, da etwas mühsam und nicht 100% exakt hinzubekommen, aber für meine Zwecke ausreichend.

Fischmaul und Flossen fehlen noch.



Da zappelt der Fisch (kurzes Video):

Herunterladen
 
vor 25 Tagen  
 




HofK
Die zweifach kurvige Geometrie ist fertiggestellt.

Curved2Geometry

Man definiert mit einige 3D Punkten die Mittelkurve und für einige Winkel die orthogonal radialen Abstände der Hülle von diesen Punkten.

Mit der Angabe der maximalen Werte bestimmt man die vertikale und radiale Feinheit der Darstellung.

Mit einem Definitionsstring aus drei Zeichen legt man fest, ob Kappen generiert werden sollen und ob diese "flat" oder "smooth" sein sollen. Das dritte Zeichen
ermöglicht das radiale verbinden ohne Naht oder eine symmetrische Geometrie. Für die symmetrische Geometrie muss der letzte Winkel 180° sein.

3 Zeichen 'string' = 'withTop withBottom conncted/symmetric'

withTop/Bottom: x, f, s = no, flat, smooth
conncted/symmetric: x, c, s = no, connected, symmetric

Mit der Angabe von Abweichungen zu den definierten Punkten der Mittelkurve lässt optional eine sehr organische Bewegung der Geometrie erzeugen.

Die Parameter und Werte werden in einer Designmatrix zusammengefasst. Das erste Zeile dieser Matrix ist ein Array der Parameter, die weiteren Zeilen enthalten in jeweils einem Array die Werte.

Auf diese Weise kann man die Werte in Spalten genau unter den Parametern platzieren.
const design = [
// first0, .. angles .. , max angle
[ maxVert.,'string', maxRadial,  0,  phi1,  phi2, ...  phimax ] ,
// center x,y,z   	        distance to center orthogonal-radial
[ x,             y,         z,  r0,   r1,    r2, ...     r ],// top
...
[                                                           ]// bottom
];

Ein Beispiel:



Da bei beliebig definierten Mittelpunkten und Winkeln und ebenso beliebigen maximalen Werten der Feinheit keine exakte Übereinstimmung möglich ist, werden die jeweils nächstgelegenen Werte ermittelt und für die Berechnung benutzt.

Die optionalen Werte der Abweichungen sind in entsprechender Struktur zu den Mittelpunkten zu notieren. Aus diesen Werten werden auf einer Kurve weitere Punkte erzeugt. Deren Anzahl ist in einem gesonderten Parameter anzugeben.

Die Bewegung wird mit Hilfe der Methode geometry.morph( geometry.cPts  ) erzeugt.

g.cPts = []; // array of array of morphed g.cPoints

wobei

g.cPoints = new THREE.CatmullRomCurve3( g.dsgnCenters, false ).getSpacedPoints( g.vertical );


Dort ansehen: [...]  =>  [...] 



Quelltext auch auf Github  [...]  und discourse  [...] 
 
vor 14 Tagen  
 




HofK
Eine entscheidende Etappe der CPU-Simulation ist erfolgreich absolviert.

Das rekursive Quicksort funktioniert.

Es benutzt zwar nicht alle Befehle, aber ist doch schon recht komplex.
Die problematischen Befehle MUL und DIV werden nicht benötigt.

Die Auswahl einer Eingabedatei ist möglich, funktioniert aber bedingt durch die Vorgaben der Browser etwas anders als unter Windows/Desktop. Dort wird der Dateiname aus dem Edit benutzt, im Browser muss man per select eine lokale Datei selbst auswählen.

Speichern in eine lokale Datei ist im Browser nicht möglich. In anderen Programmen habe ich das Problem derart gelöst, das die Werte über ein textarea in die Zwischenablage kopiert werden. Siehe z.B.  [...] 

Also den Code entsprechend übernommen, getestet - die Zwischenablage ist leer!

In der Konsole/Warnungen findet man



Ist wohl wieder mal ein Sicherheitsfeature. Nur dumm, dass all diese Dinge den normalen Nutzer ausbremsen, aber die Ganoven nicht davon abhalten über die immer wieder neu entdeckten Schlupflöcher ihr Unwesen zu treiben.

Also werde ich analog zum Input ein copy unter das Feld setzen. Der Nutzer muss dann eben nochmal klicken, wenn er das Ergebnis nicht nur im RAM haben möchte.

Ausprobieren:  [...] 

Dateien unter  [...] 

Vor Run input.hcx selektieren!



Quicksort rekursiv.txt
HC680 Assembler    ; Quicksort rekursiv
00: ST             ; Startadr.
Adr Mnm _Op_ _Op_  ; - Kommentar -
00: MOV .SR. .01.  ;IO = 01 : Dezimalzahlen in zu sortierender/sortierter Datei
01  INC .A1.       :Index für RCL auf 1
02: RCL            ;Daten zur Sortierung einlesen, ab Adr. h81 ablegen, Anzahl in D0
03: PSH .D0.       ;Anzahl merken
04: LDC .D1.       ;lade h80 (Adresse vor Sortierdatenbereich) ...
05: ##  1000 0000  ;
06: ADD .D1. .D0.  ; ... + Anzahl gelesener = Endadresse Sortierdaten (unten, Parameter)
07: LDC .D0.       ;lade h81 = Anfangsadresse Sortierdaten (oben, Parameter)
08: ##  1000 0001  ;
09: LDC .A0.       ;Adr. 17 = h11 für Aufruf Sub Quicksort nach A0 bringen
0A: ##  0001 0001  ;
0B: JSR            ;Sprung zum Unterprogramm Quicksort
0C: POP .D0.       ;Anzahl Daten holen
0D: CLR .A1.       ;Index für STO ...
0E: INC .A1.       ;... auf 1 bringen (Sortierte Daten ab h81 im RAM)
0F: STO            ;sortierte Daten in Datei schreiben
10: STP            ;----- Hauptprogramm anhalten -----
11: NOP            ;<Start sub quicksort> / Pivotelement ist unten
12: LDC .A1.       ;Sprungdifferenz dez 71 laden <= einelementiger Bereich
13: ##  0100 0111  ;
14: MOV .A0. .D1.  ;Adr unteres Element umspeichern für Vergleich
15: SUB .A0. .D0.  ;Adressen oben/unten vergleichen
16: DEC .A0.       ;(A0)D1 = D0 berücksichtigen (0 -> -1)
17: JIN .+A.       ;--- Sprung wenn nur einelementiger Bereich
18: PSH .D0.       ;Adr oberes Element merken
19: MOV .A0. .D0.  ;obere Adr ins Adressregister (laufender Zeiger oben Zo)
1A: DEC .A0.       ;Adr. DEC, da in Schleife erst INC vor Vergleich
1B: PSH .D1.       ;Adr unteres Element merken
1C: SSR .D1.       ;Adr laufender Zeiger unten (Zu) in Schattenregister bringen
1D: MOV .D1. [D1]  ;Wert unteres Pivot-Element (P) laden
1E: PSH .D1.       ;Wert P merken
1F: NOP            ;<-- Sprungziel äußere Schleife
20: LDC .A1.       ;negative Sprungdiff. dez -3 für Schleife laden
21: ##  1111 1101  ;=
22: INC .A0.       ;<-- Sprungziel - Adr Zo weiter runter schieben
23: MOV .D0. [A0]  ;laufenden oberen Wert laden
24: CMP            ;laufenden Wert mit P in D1 vergleichen
25: JIN .+A.       ;Schleife bis >=  (Fehlplatzierung)
26: MOV .D0. .A0.  ;letze Adresse Zo umspeichern
27: SSR .D0.       ;Adr Zo merken (Fehlplatzierung)
28: LDC .A1.       ;neue Sprungdiff. dez -12 laden
29: ##  1111 0100  ;
2A: GSR .D1.       ;Adr Zu holen ...
2B: MOV .A0. .D1.  ; ... ins Adressreg.
2C: POP .D0.       ;<-- Sprungziel - Wert P nach D0 holen (beachte: umgekehrter Vergleich!) ...
2D: PSH .D0.       ;... und wieder merken
2E: DEC .A0.       ;Adr Zu weiter hoch schieben
2F: MOV .D1. [A0]  ;laufenden unteren Wert laden
30: SUB .D0. .D1.  ;Differenz  Wert zu Pivotelement
31: PSH .D0.       ;Diff. merken (Vorzeichen für Vergleich)
32: MOV .D1. .A0.  ;Adr Zu nach D1 bringen
33: SSR .D1.       ;letzte Adr Zu merken
34: GSR .D0.       ;letzte Adr Zo holen
35: SUB .D0. .D1.  ;Differenz Zeiger Zo - Zu
36: POP .D1.       ;Differenz Wert zu Pivotelement holen
37: AND .D0. .D1.  ; --- Schleifenbed. verknüpfen --- nur Vorzeichen (eine Diff. positiv )
38: JIN .+A.       ;Schleife bis <= Wertvergleich (Fehlplatzierung)  oder >= Zeigervergleich
39: LDC .A1.       ;--- Abbruchprüfung äußere Schleife  Sprungdiff. dez 12 für Schleifenabbruch laden
3A: ##  0000 1100  ;
3B: GSR .D1.       ;letzte Adr Zu holen
3C: GSR .D0.       ;letzte Adr Zo holen
3D: SUB .D1. .D0.  ;Differenz Zeiger umgekehrt Zu - Zo  für Abbruchentscheidung
3E: DEC .D1.       ;wenn negativ: Zeiger (Adressen) gleich oder überlaufen sich
3F: JIN .+A.       ;-> Abbruch der  äußeren Schleife
40: NOP            ;--- Tausch bei Fehlplatzierung
41: GSR .D0.       ;Adr Zo holen
42: GSR .D1.       ;Adr Zu holen
43: SWM            ;Tausch Werte im RAM:  Adr D0 <-> Adr D1  (Zo, Zu)
44: MOV .A0. .D0.  ;Zo nach AO
45: POP .D1.       ;Wert Pivotel. laden für Vergleich nach Rücksprung
46: PSH .D1.       ;und Wert P wieder merken
47: LDC .A1.       ;Rücksprungsdiff. dez -42 äußere Schleife in A1 laden
48: ##  1101 0110  ;
49: JMP .+A.       ;Rücksprung an Stelle: äußere Schleife (Weiterführung der Vergleiche)
4A: NOP            ;--- Ende äußere Schleife --- Tausch Trennelement:
4B: GSR .D0.       ;Adr Zo  holen (Platz für Trennelement)
4C: POP .D1.       ;Wert Pivotel. vom Stack abräumen
4D: POP .D1.       ;AdrPivotel. unten laden (dann auch als Parameter)
4E: SWM            ;Tausch Werte im RAM:  Adr D0 <-> Adr D1 ( Zo <-> Pivot-/Trennelement)
4F: PSH .D1.       ;Adr unten wieder merken  (Parameter)
50: PSH .D0.       ;Adr Trennelement merken
51: INC .D0.       ;Adr: Trennel. + 1  (Parameter)
52: LDC .A0.       ;Adresse dez 17 = h11 für Rekursion Quicksort laden
53: ##  0001 0001  ;
54: CLR .A1.       ;kein weiterer Index für Aufruf
55: JSR            ;---> rekursiver Aufruf Quicksort (zuerst rechts)
56: POP .D1.       ;Adr Trennelement laden
57: DEC .D1.       ;Adr Trennel. - 1   (Parameter)
58: POP .D0.       ;Adr unten laden -verwerfen
59: POP .D0.       ;Adr oben laden     (Parameter)  ->  Stack abgeräumt!
5A: LDC .A0.       ;Adresse dez 17 = h11 für Rekursion Quicksort laden
5B: ##  0001 0001  ;
5C: CLR .A1.       ;kein weiterer Index  für Aufruf
5D: JSR            ;---> rekursiver Aufruf Quicksort (nun links)
5E: RET            ;-----> Rücksprung aus Sub Quicksort
5F: NOP            ;
60: NOP            ;
 
vor 5 Tagen  
 




HofK
Mittlerweile klappt nun kopieren in die Zwischenablage.

Mit der Farbänderung der Buttonschriftfarbe von "to Clipboard" wird signalisiert, dass die Speicherung STO erfolgt ist und der Button betätigt werden kann. Damit ist ein Browser zufrieden - Firefox!!!

Bei Chrome keine Fehlermeldung, aber es passiert nichts.


Irgendwie verliert man da die Lust für Browser etwas zu programmieren. Weil Chaos herrscht soll man für jeden Browser eine Extrawurst braten.

Dazu habe ich keine Lust und werde mich fortan auf Firefox beschränken und das vermerken. Aber auch da kann es passieren, das nach einiger Zeit nichts mehr funktioniert. Wie beim Video, wo alte Beispiele nicht mehr laufen, weil seit einiger Zeit auch hier ein Nutzerbutton Pflicht ist. War der in alten Beispielen (z.B. in meiner Sammlung von Discourse ) nicht da, funktioniert das heruntergeladene Beispiel nicht mehr.
 

Das Chaos ist sogar "sauber" dokumentiert:  [...] 

Zitat:
"The clipboard and other APIs involved here are evolving rapidly, so there are variations among browsers in how they work."

Die "neue" Clipboard API mag ich gar nicht erst testen,

Wer also probieren möchte - bitte Firefox benutzen.  [...] 

Damit der Test schnell geht den Schieber "clock speed" ganz nach rechts schieben und eine kleine input - Datei wählen, z.B. inputA.hcx von  [...] 
 
vor 2 h  
 




Antworten


Thementitel, max. 100 Zeichen.
 

Systemprofile:

Kein Systemprofil angelegt. [anlegen]

XProfan:

 Beitrag  Schrift  Smilies  ▼ 

Bitte anmelden um einen Beitrag zu verfassen.
 

Themenoptionen

138.669 Betrachtungen

Unbenanntvor 0 min.
Manfred Bareivor 59 min.
E.T.vor 73 min.
RudiB.vor 117 min.
HofKvor 2 h
Mehr...

Themeninformationen



Admins  |  AGB  |  Anwendungen  |  Autoren  |  Chat  |  Datenschutz  |  Download  |  Eingangshalle  |  Hilfe  |  Händlerportal  |  Impressum  |  Mart  |  Schnittstellen  |  SDK  |  Services  |  Spiele  |  Suche  |  Support

Ein Projekt aller XProfaner, die es gibt!


Mein XProfan
Private Nachrichten
Eigenes Ablageforum
Themen-Merkliste
Eigene Beiträge
Eigene Themen
Zwischenablage
Abmelden
 Deutsch English Français Español Italia
Übersetzungen

Datenschutz


Wir verwenden Cookies nur als Session-Cookies wegen der technischen Notwendigkeit und bei uns gibt es keine Cookies von Drittanbietern.

Wenn du hier auf unsere Webseite klickst oder navigierst, stimmst du unserer Erfassung von Informationen in unseren Cookies auf XProfan.Net zu.

Weitere Informationen zu unseren Cookies und dazu, wie du die Kontrolle darüber behältst, findest du in unserer nachfolgenden Datenschutzerklärung.


einverstandenDatenschutzerklärung
Ich möchte keinen Cookie