draw_rectangle dicke der linien?

  • Hier hast du 2 scripts für sowas (nicht getestet!)

    GML-Quellcode

    1. ///draw_rectangle_width(x1,y1,x2,y2,width,colour);
    2. var x1 = argument0;
    3. var x2 = argument2;
    4. var y1 = argument1;
    5. var y2 = argument3;
    6. var w = argument4;
    7. var c = argument5;
    9. draw_set_colour(c);
    11. //rechtecke in die Ecken des Vierecks zeichnen um leere Ecken zu kompensieren bei einer dicke > 1
    12. if w > 1
    13. {
    14. draw_rectangle(x1-(w/2),y1-(w/2),x1+(w/2),y1+(w/2),false);
    15. draw_rectangle(x2-(w/2),y2-(w/2),x2+(w/2),y2+(w/2),false);
    16. draw_rectangle(x1-(w/2),y2-(w/2),x1+(w/2),y2+(w/2),false);
    17. draw_rectangle(x2-(w/2),y1-(w/2),x2+(w/2),y1+(w/2),false);
    18. }
    19. //das eigtl rechteck
    20. draw_line_width(x1,y1,x2,y1,w);
    21. draw_line_width(x1,y2,x2,y2,w);
    22. draw_line_width(x1,y1,x1,y2,w);
    23. draw_line_width(x2,y1,x2,y1,w);
    25. draw_set_colour(c_white);
    Alles anzeigen


    und für kreise

    GML-Quellcode

    1. ///draw_circle_width(x,y,radius,width,colour);
    3. var x = argument0;
    4. var y = argument1;
    5. var r = argument2;
    6. var w = argument3;
    7. var c = argument4;
    9. draw_set_colour(c);
    11. for (dir = 0 ; dir < 360 ; dir += 1)//dir += 0.5 gibt dir die doppelte präzision, du könntest es berechnen lassen je nach radius (je kleiner der radius desto größer der wert der zu dir addiert wird)
    12. {
    13. var x1 = x+lengthdir_x(r,dir);
    14. var y1 = y+lengthdir_y(r,dir);
    15. var x2 = x+lengthdir_x(r,dir+1);
    16. var y2 = y+lengthdir_y(r,dir+1);
    17. draw_line_width(x1,y1,x2,y2,w);
    18. draw_circle(x1,y1,w/2,false)
    19. }
    21. draw_set_colour(c_white);
    Alles anzeigen

    out now: KNOSSOS auf itch.io
    ancient-pixel.com <<< ich freue mich über einen Besuch! ^^

  • Solange das was du machen willst nicht dynamisch sein soll würde ich empfehlen hauptsächlich auf Sprites zurückzugreifen
    und möglichst viel damit zusammenzufassen. In vielen Fällen kann man ein GUI durch ein einziges Sprite lösen (abgesehen von dyn. Inhalten wie Trefferpunkte, Score, etc.)
    Spart Performance, da draw_line(), draw_rectangle(), usw. schnell zu Lasten der CPU fallen.

  • Ja richtig @RLP, die draw calls können sehr taxing sein. Mitunter kann man da statt draw_rects usw draw_primitive verwenden. @Husi012 arbeitet ja momentan auch an Skripten um Polygone zu drawen, vllt hat er auch eine bestimmte Technik gefunden, die das System nicht belastet. Er will ja ein ganzes Spiel draus machen das nur aus solchen Grafiken besteht.

    out now: KNOSSOS auf itch.io
    ancient-pixel.com <<< ich freue mich über einen Besuch! ^^

  • Aku_Ryou schrieb:

    Mitunter kann man da statt draw_rects usw draw_primitive verwenden

    In vielen Fällen ja, aber so weit ich das sehe gibt es dabei keine Funktionen um die Dicke von Linien zu variieren (korrigiert mich wenn ich falsch liege).
    Das geht wohl leider nur über "teure" Umwege.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von RLP ()

  • Off-Topic
    @Aku_Ryou
    Eigentlich benutze ich die einfachen draw_* Funktionen. Ich müsste mir doch mal anschauen, wie man das umgehen könnte :D
    Noch habe ich auch keine Performanceeinbußen bemerkt :saint:
    Im Moment weiß ich grad nicht mal, warum die so CPU lastig sind ^^
    Ein Bug ist mehr als nur ein Bug, es ist ein... Käfer!
    Egal, wie gut du eine Mauer baust, sie fällt um.... der klügere gibt nach :D

    Willst du mit mir auf Discord Chatten/Quatschen?
    Meine Husi's Tutorial Reihe

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Husi012 ()

  • Husi012 schrieb:

    Im Moment weiß ich grad nicht mal, warum die so CPU lastig sind

    Das liegt an den Draw-Calls.

    Soweit ich weiß, gilt jede Art etwas zu drawen als Draw-Call (Sprite, Background, fertige Primitives, Rectangles, ...).
    Diese werden von der CPU berechnet, außer man macht sie direkt im Shadercode.

    Also auch jede einzelne draw_line oder draw_point ist ein Draw-Call.
    Deswegen auch mein Vorschlag alles so weit es geht in ein Sprite oder wenige Sprites zusammenzufassen (wenn ein Interface recht statisch ist ist das ja kein Problem)

    Wenn dein Spiel nur aus den draw-Funktionen besteht @Husi012 und diese oft benutzt werden,
    kannst du damit rechnen, dass es auf Android z.b. ruckelt. Auf einem Gamer-PC wird man das nicht so schnell merken,
    nur wenn man es wirklich deutlich übertreibt.

    Im Profiler vom GM sieht man auch sehr schön die Auslastung der einzelnen Funktionen.

  • Ich habe dieses Problem mal auf dem offiziellen Forum gepostet (Link) und mir wurde die Lösung mit einem Vertex Buffer vorgeschlagen.
    Testweise habe ich mal die Zeit bei 20000000 calls (draw_point) gestoppt.
    Ganz normal habe ich über current_time 12925ms stoppen können
    und mit einem Vertex Buffer nur 1547ms
    Eine Leistungssteigerung von ganzen 735,5%
    Im gefreezten Zustand hat es sogar nur 1ms gedauert!

    Um dies auf die Rechtecke zu beziehen:
    scr_create_rectangle_vertexbuffer

    GML-Quellcode

    1. ///scr_create_rectangle_vertexbuffer(x1,y1, x2,y2, w)
    2. vertex_format_begin();
    3. vertex_format_add_position();
    4. var format = vertex_format_end();
    5. var vbuff = vertex_create_buffer();
    6. vertex_begin(vbuff,format);
    7. for(var i=0; i<argument4; i++){
    8. vertex_position(vbuff, argument0+i,argument1+i);
    9. vertex_position(vbuff, argument2-i,argument1+i);
    10. vertex_position(vbuff, argument2-i,argument3-i);
    11. vertex_position(vbuff, argument0+i,argument3-i);
    12. vertex_position(vbuff, argument0+i,argument1+i);
    13. }
    14. vertex_end(vbuff);
    15. vertex_freeze(vbuff);
    16. return vbuff;
    Alles anzeigen

    Der Code ist jetzt nicht geprüft.
    Um ihn anzuwenden musst du folgendes tun:
    Erstellen des Rechtecks

    GML-Quellcode

    1. rectangle = scr_create_rectangle_vertexbuffer(x1,y1,x2,y2, deineBreite);

    Zeichnen des Rechtecks

    GML-Quellcode

    1. vertex_submit(rectangle, pr_linestrip, -1);

    Das Rechteck aus dem Speicher leeren (sollte gemacht werden, bevor ein neues Vertex erstellt wird)

    GML-Quellcode

    1. vertex_delete_buffer(rectangle);
    Ein Bug ist mehr als nur ein Bug, es ist ein... Käfer!
    Egal, wie gut du eine Mauer baust, sie fällt um.... der klügere gibt nach :D

    Willst du mit mir auf Discord Chatten/Quatschen?
    Meine Husi's Tutorial Reihe

  • Aha! Vertex-Buffer. :) Macht Sinn. Was für Polygone gilt sollte natürlich auch für 2D-Formen gelten, da diese intern ja einfach 2D-Polygone sind.
    Super, dass du da nachgeforscht und selbst experimentiert hast.