[*]Profan

Nachtrag:
iF

Ich möchte nicht beginnen mir selbst wie eine Nervensäge vorzukommen.

Zu spät!

07.04.2009 ▲

OGL.DRAWSYSTEXT hat heute sein 2 jähriges Warten auf eine Reaktion aufgegeben, findet leider nur in z.B. einer DLL sein Zuhause.

Statt dieser lauter Beiträge hätte ich mir solch DLL gleich schreiben können, aber ich wollte zeigen was per tolle Giochi man mit XProfan herstellen kann - mit reinem XProfan um besonders damit zu werben auch im Spiel.

RGH

Hallo iF,

ich habe mich mit einer Kontainerfunktion experimental noch nicht so recht anfreunden können.
Das birgt doch die Gefahr, dass Fonte mit dieser Funktion veröffentlicht werden und diese auch noch Monate und Jahre nach der Veröffentlichung in den Weiten des WWW (oder dieser Community) herumgeistern. Dann kommen sicher bald irgendwelche Leute, die diese herunterladen und ausprobieren wollen und wieder kurz vor einem Herzkasper stehen, weil diese experimentellen Kontainerfunktionen nicht mehr oder anders funktionieren und sie nun die riesigen Quellcodes umschreiben müssen.

Zu Deiner OGL-Funktion: Füge doch mal ein kurzes XProfan-Beispielprogramm hinzu, mit dem man sieht, was sie macht und was ihre Fähigkeiten demonstriert und erleutere ihre Parameter mal in verständlichem (Hilfedatei-geeignetem) Deutsch. Dann schaue ich mir die Sache mal an und packe sie möglicherweise auf die ToDo-Liste per die nächste XProfan-Version. Versprochen!

Saluto
Roland

Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD - ATI Radeon HD 4770 512 MB - Windows 7 Home Premium 32Bit - XProfan X4

Schrift/Textausgaben malen, die/eine Textur-File beinhaltet alle Chars und die Funktion zeichnet aus diesen Chars entsprechend texturierte Vertexe sodass der an die Funktion übergebene String per OpenGL ausgegeben wird.

Die Parameter:

X!,Y! : Position des auszugebenen Textes
TXT$ : Auszugebener Text

Optionale Parameter
SZ! : YX Skalierungsfaktor/Schriftgrösse
SZY! : Vertikal-Verzerrung per typische Effekte
HOPX! : Sprungweite zwischen den Chars
SZX! : Horizontal-Verzerrung per typische Effekte

Die obige Funktion ist (naturalmente) optimiert auf schnelle Ausführung per XProfan - ein Delphi oder C Code würde sicher etwas anders programmiert mehr Geschwindigkeit bringen. (z.B. ohne MID$ in der Schleife)

Das oben ist nur eine abgespeckte Variante, das Original hat noch eine optionale xtraProcAddr um Texte z.B. einfach von aussen Rotieren oder Knicken zu lassen.
Kompilieren Markieren Separieren

ogl.drawSysText(float x,y,string txt,float sz,szY,hopX,szX,xtraProcAddr){

    case pcount<8 : xtraProcAddr=0
    case pcount<7 : szX=1
    case pcount<6 : hopX=1
    case pcount<5 : szY=1
    case pcount<4 : sz=1
    hopX=hopX*sz
    szX=szX*sz
    float xx=x+32*szX
    float yy=y+32*sz*szY
    float tx,ty,txx,tyy
    long column,row,o,c=len(txt)
    ogl.push
    ogl(texture,ogl.texSysfnt,1)
    hopX=16*hopX
    case xtraProcAddr:call(xtraProcAddr,c,0,(x-xx)*1000000,(y-yy)*1000000,hopX*1000000)

    whileloop c {

        o=ord(mid$(txt,loop,1))
        column=o16
        row=o-column*16
        tx=0.0625*column-0.005
        ty=0.0625*(16-row-1)-0.005
        txx=tx+0.0625
        tyy=ty+0.0625
        case xtraProcAddr:call(xtraProcAddr,c,loop,(x-xx)*1000000,(y-yy)*1000000,hopX*1000000)
        oGL(glBegin,GL_QUADS)
        oGL(glTexCoord2f,tx,tyy)
        oGL(glVertex3f,x,y,)
        oGL(glTexCoord2f,txx,tyy)
        oGL(glVertex3f,xx,y,)
        oGL(glTexCoord2f,txx,ty)
        oGL(glVertex3f,xx,yy,)
        oGL(glTexCoord2f,tx,ty)
        oGL(glVertex3f,x,yy,)
        ogl(glEnd)
        casenot xtraProcAddr:ogl(move,hopX,,)

    }

    ogl.pop
    return hopX

}

Das mit der xtraProcAddr ist im Grunde eine einfache (zugleich aber äusserst wirkungsvolle) Sache, habe ich aber leider noch kein Feedback auf die Frage ob Du aus XProfan heraus eine XProfan-Funktion aufrufen kannst deren Adresse per ProcAddr bezogen wurde. (Ich glaube aber: Natürlich) Darum habe ich diesen Part aus dem obigestem Code zu ogl.drawSysText erstmal herausgenommen auch um nicht völlig zu verwirren.

Ebenso - aber nur um Beispiele zu nennen per vielleicht testweise implementierbare Funktionen - habe ich Helfer-Schleifen (Funktionen) per Terrainbildung auf einer Fläche oder auf einem Sphere mühsam (per mich mühsam) erstellt, der Vorgang per XProfan unschön lange braucht aber nativ eingebunden (was imho ein Klax ist) wäre es sehr bereichernd und weitere Ideen fördernd.

Zum Thema experimental: Das ist ein Gedankenanstoss!

Ähnlich wie es z.B. in OpenGL-Umsetzungen experimentelle Funktionen gibt mit Vorzeichen des Experimenterfinders nvx_* ata_* wäre es vielleicht ganz praktisch wenn Du Funktionen - z.B. welche erstmalig in einer Version zu Versuchszwecken implementiert wurden - schonmal anbietest aber erklärst: Kein Sostegno/ Keine Garantie/ Experimentalfunktionen.

Gedacht hierfür hatte ich (naturalmente) eine Kontainerfunktion um keine IDs zu verbraten - ich aber glaube (leider _auch nicht _weiss, weil kein Response zu [...]

), dass es ein IDs-Problem nicht mehr gibt.

Vielleicht also auch einfach durchzählen also experimental(1..x,param1..x).

Zu den Codes die dann rumschwirren: Da es (kein?) IDs-Problem gibt sollte es nichts ausmachen, eine später komplett integrierte Version einer Funktion auch später noch per Kontainerfunktion experimental aufrufbar zu gestalten.

Der einzig technische Nachteil der sich mir erschließt wäre, dass die Runtime um ein paar Byte an Grösse gewinnt.

Was wäre optimal: Wenn ein jemand eine tolle Funktion postet mit Bitte um Antestung einer leichtfüssigen Integrierung per mehr Geschwindigkeit: Klar, kein Problem per Roland - ab nach experimental. Vielleicht entsteht dann aus der einen oder anderen experimentellen Funktion - welche sich vlt. auch schon in lauter Versionen behauptet hat - eine neue echte Funktion.

2011 dann gleiche Stelle gleiche Welle?

RGH

Hallo iF,

ich habe mich mit einer Kontainerfunktion experimental noch nicht so recht anfreunden können.

Dann nenne sie doch RGH!

(Mir ist schon klar, dass es Dir nicht um die Benennung geht, ich finde experimental auch doof...)

RGH

Hallo iF,
es fehlt mir immer noch ein Beispielcode, um obige (ganz weit obige) Funktion mal auszuprobieren und in Aktion zu sehen.
Saluto
Roland

Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD - ATI Radeon HD 4770 512 MB - Windows 7 Home Premium 32Bit - XProfan X4

Jupp, habe nur Zuhause mein /develope - ich bau Dir was Schönes hierzu zurecht.

Rumstreunende (und kompilierte) Beispiele gibts in der Community jedoch einige, z.B. auch immer wenn ich das Thema versuchte wieder (vorsichtig) anzustreifen.

Jedoch wäre es schön per mich zu wissen, ob ich einer XProfan-Funktion eine mit ProcAddr bezogene Funktionsadresse trasferimento kann sodass diese per ProcAddr bezogene Funktion dann von der nativen XProfan-Funktion im Bedarfsfall corsa werden potuto. (Callbacks wenn Du so möchtest.)

Dann würde ich nämlich lieber gleich die Variante _mit xtraProcAddr übersetzt beispielisieren, gingen darüber dann tolle Effekt wie z.B. sich um ein Zentrum drehende Chars oder Chars auf Sinuswelle etc..

Nur ohne die nativ vorliegende Hilfsfunktion im XProfan leider nicht wirklich in z.B. Spielen zeitkritisch und effektiv einsetzbar.

RGH

Ciao,
ich würde zuerst die erste Variante (ohne diese ProcAddr-Geschichte) vorziehen und mal anschauen, ob daraus was per XProfan 12 werden kann.
Saluto
Roland

Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD - ATI Radeon HD 4770 512 MB - Windows 7 Home Premium 32Bit - XProfan X4

Eine durchdachtere Variante wäre eine oglDrawTiles-Funktion, per die ich mal ein Minimalbeispiel (haha) aufbereitet habe:
Kompilieren Markieren Separieren

 {$iq}
def &screenX 1024
def &screenY 768
window &screenX,&screenY
hWnd.setInnerSize(&screenX,&screenY)
var hPic&=create(hNewPic,512,512,0)
var y&=
startPaint hPic&
useFont fixedsys,1,0,0,0,0
textColor $FFFFFF,-1

whileLoop 256

    drawText &loop mod 16*32,&loop16*32,chr$(&loop+1)

wend

endPaint
savepic fixedsys.bmp,hpic&
startpaint hPic&
cls $008800
usePen 0,0,$33BB33

whileLoop 0,16

    line &loop*32,0 - &loop*32,512
    line 0,&loop*32 - 512,&loop*32

wend

usePen 0,0,$006611

whileLoop 0,16

    line 0,(&loop*32-1) - 512,(&loop*32-1)
    line (&loop*32-1),0 - (&loop*32-1),512

wend

whileLoop 5000

    setPixel rnd(512),rnd(512),$55EE55

wend

savepic grid.bmp,hpic&
deleteObject hPic&
//
ogl(init,%hWnd,0,0,0,0)
var meineTiles&=ogl(loadTextureBMP,fixedsys.bmp,1)
var meineTiles2&=ogl(loadTextureBMP,grid.bmp,1)
ogl(posMode,1)
var myList&=ogl(startList)
var s$=

whileLoop 16

    s$=

    whileLoop 16

        s$=s$+chr$(&loop+y&*16)

    wend

    ogl.drawTiles(0,100+y&*16,s$,16,32,1,0.25)
    inc y&

wend

ogl(endList)
var pa&=procAddr(myOGLTileOutCallBackProc,4)
var fps&=0
var fpsT&=&getTickCount+1000
var fpsC&=0

while 1

    inc fpsC&

    if fpsT&<&getTickCount

        inc fpsT&,1000
        fps&=fpsC&
        fpsC&=0

    endif

    ogl(clear)
    ogl(move,0,0,-5)
    ogl(texture,meineTiles&,1)
    ogl(color,0,0,1,1)
    ogl(rotate,&getTickCount/700,&getTickCount/500,&getTickCount/300)
    ogl(cuboid,1,1,1)
    ogl(color,1,1,1,1)
    ogl.2d()
    ogl(drawList,myList&)
    ogl.drawTiles(0,0,ABC Hallo Welt: +str$(&getTickCount),16,32,1,0.25)
    ogl.drawTiles(0,200,ABC Hallo Welt: +str$(&getTickCount),16,32,4,0.25,pa&)
    ogl(color,0,1,0,1)
    ogl.drawTiles(0,500,FPS: +str$(fps&),16,32,1,0.25)
    ogl(color,1,1,1,1)
    ogl(texture,meineTiles2&,1)

    whileLoop 16

        ogl.drawTiles(650,5+&loop*32,chr$(&loop*4)+chr$(&loop*4+1)+chr$(&loop*4+2)+chr$(&loop*4+3),16,32)

    wend

    testCorrectOriginLines()
    ogl(show)
    case %mousePressed=2 : break

wend

//ogl(deleteTexture,1)
ogl(done)
end

proc myOGLTileOutCallBackProc

    parameters x&,y&,c&,o&
    ogl(move,c&*35,sin(c&+&getTickCount*0.003)*10+350,0)
    //ogl(color,rnd(2),rnd(2),rnd(2),1)

endproc

proc ogl.drawTiles

    parameters x!,y!,tiles$,tilesPerRow&,pixelPerTile&,scaleF!,dropF!,tileOutCallBack&
    case %pCount<8 : tileOutCallBack&=0
    case %pCount<7 : dropF!=1
    case %pCount<6 : scaleF!=1
    var c&=len(tiles$)
    casenot c& : return x!
    var COLUMN&=0
    var ROW&=0
    var TX!=0
    var TY!=0
    var TXX!=0
    var TYY!=0
    var o&=0
    var f!=(1/tilesPerRow&)
    var xx!=x!+pixelPerTile&*scaleF!
    var yy!=y!+pixelPerTile&*scaleF!
    ogl(push)

    whileLoop c&

        o&=ord(mid$(tiles$,&loop,1))-1
        row&=o&*f!
        column&=o&-row&*tilesPerRow&
        tx!=f!*column&
        ty!=f!*(tilesPerRow&-row&-1)
        txx!=tx!+f!
        tyy!=ty!+f!
        messagebox str$(tx!)+ +str$(ty!)+ +str$(txx!)+ +str$(tyy!),,0

        if tileOutCallBack&

            ogl(push)
            call(tileOutCallBack&,int(x!),int(y!),&loop,o&)

        endif

        oGL(glBegin,~GL_QUADS)
        oGL(glTexCoord2f,tx!,tyy!)
        oGL(glVertex3f,x!,y!,0)
        oGL(glTexCoord2f,txx!,tyy!)
        oGL(glVertex3f,xx!,y!,0)
        oGL(glTexCoord2f,txx!,ty!)
        oGL(glVertex3f,xx!,yy!,0)
        oGL(glTexCoord2f,tx!,ty!)
        oGL(glVertex3f,x!,yy!,0)
        ogl(glEnd)

        ifnot tileOutCallBack&

            ogl(move,pixelPerTile&*dropF!*scaleF!,0,0)

        else

            ogl(pop)

        endif

    wend

    OGL(pop)
    RETURN pixelPerTile&*c&*dropF!*scaleF!

endproc

proc ogl.2d

    ogl(origin,0,0,0)
    ogl(posmode,1)
    ogl(glMatrixMode,~GL_PROJECTION)
    ogl.ortho(0,&screenY,&screenX,0,0,256)

endproc

proc ogl.ortho

    parameters x&,y&,xx&,yy&,z&,zz&
    ogl(glLoadIdentity)
    ogl(glViewport,0,0,&screenX,&screenY)
    declare m#
    dim m#,48
    float m#,0 =x&,xx&,y&,yy&,z&,zz&
    ogl(glOrtho,long(m#,0 ),long(m#,4 ),long(m#,8 ),long(m#,12),long(m#,16),long(m#,20),long(m#,24),long(m#,28),long(m#,32),long(m#,36),long(m#,40),long(m#,44))
    dispose m#

endproc

proc hWnd.setInnerSize

    parameters x&,y&
    setwindowpos %hWnd = %winLeft,%winTop - ((%winRight-%winLeft)-(width(%hWnd)-x&)),((%winBottom-%winTop)-(height(%hWnd)-y&));0

endproc

proc ogl.line

    parameters x!,y!,xx!,yy!
    ogl(glBegin,~GL_LINES)
    ogl(glVertex3f,x!,y!,)
    ogl(glVertex3f,xx!,yy!,)
    ogl(glEnd)

endproc

proc testCorrectOriginLines

    ogl(color,1,1,1,1)

    whileLoop 0,&screenX,2

        ogl.line(&loop,0,&loop,&screenY)

    wend

    whileLoop 0,&screenY,2

        ogl.line(0,&loop,&screenX<

a class=s4 href='./../../function-references/xprofan/loop/'>loop) wend endproc

Wohlbemerkt es nur um die Funktion ogl.drawTiles ginge. (mit oder ohne extraproc)

So kann man neben der Nützlichkeit schnell Tiles anzuzeigen diese Funktion auch per die schnelle derartige Textausgabe einsetzen.

Dokument1.exe

1.033 kB

Hochgeladen:

09.04.2009

Downloadcounter:

Download

dokument2.exe

1.034 kB

Hochgeladen:

09.04.2009

Downloadcounter:

Download

09.04.2009 ▲

Ich habe den Beispielquelltext per oglDrawTiles nochmals überarbeitet/aktualisiert, an der Funktion ogl.drawTiles selbst hat sich nichts geändert.

Im Interpreter erreiche bei dem neuen Beispiel 4 FPS und mit Runtime um die 20 FPS.

Wäre ogl.drawTiles nativ würde der Interpreter bei mir ~20 FPS und die Runtime bei abgeschaltetem VSync ~110 FPS erreichen was naturalmente klasse wäre.

09.04.2009 ▲