http://www.glbasic.com/showroom.php?lang=de&game=AC3DPoly
Endlich ein einfacher Weg um 2D Vectorgrafiken zu laden und nutzen.
Freak :D
Ist cool!
Genial!
Das schreit nach einem Test!
OK, Update. Kollisionen gehen jetzt (auch mit Drehen + Strecken usw.)
Mann, ist das jetzt easy da ein Spiel zu machen. Wer hat Lust?
Ich mache ein Fun - Level in LR damit! hehehe
Das sieht sicher super aus...
wo gibt es ein freeewareprogramm um diese daten zu erzeugen?
mfg
@ sechsrad
Gernot hat ja eine Readme dazugepackt, es gibt das Freewareprogramm "Blender" das *.ac3d Dateien exportieren kann. Außerdem kann man sich eine 14 Tage Testversion von "AC3D" runterladen.
Ein Frage an die AC3D Anwender: Was muss ich machen um eigene Texturen auf einem ac3d Modell auch in GLB zu sehen?
In die Datei einbinden? Extra laden? Oder geht das mit der Testversion nicht?
Grüße, Tiuz.
jup, danke.habe jetzt blender am laufen , funktioniert wunderbar mit den ac - dateien.
import und export !!!
QuoteAußerdem kann man sich eine 14 Tage Testversion von "AC3D" runterladen.
für unsere belange ein bisschen zu teuer.
gernot, mich würde jetzt mal interessieren, wie ich den drehpunkt verschieben kann vom poly , bzw wo wird der drehpunkt eigentlich aus der ac-datei ausglesen??
mfg
Antwort:
1.Keine Doppelposts machen!
2.Der Drehpunkt ist immer der 0,0,0 - Punkt aus deinem 3D-Model!
Ist es möglich bei diesen 2D Vektorgrafiken eigene Texturen zu verwenden?
Grüße, Tiuz.
hier kann man den drehpunkt von dem gesamten vectorkörper x und y verlagern :
(auszug aus der dateibac3d.gbas)
px = pt.x*scalex +- wert
py = pt.y*scaley +- wert
// ----------------------------------------
// Roto-Zoom-Stretch an AC3D shape
// ----------------------------------------
FUNCTION AC3D_RotoZoom: iShape, x, y, phi, scalex, scaley
LOCAL cphi = COS(phi)
LOCAL sphi = SIN(phi)
LOCAL px,py
LOCAL textur
FOREACH pol IN gAc3dModl[iShape].poly[]
ALPHAMODE pol.transparency
STARTPOLY 0
FOREACH pt IN pol.pts[]
px = pt.x*scalex
py = pt.y*scaley
POLYVECTOR x + px*cphi + py*sphi, y - px*sphi + py*cphi, 0,0,pol.color
NEXT
ENDPOLY
NEXT
ALPHAMODE 0
ENDFUNCTIONmfg
Texturen mach' ich auch rein. Ist ja kein Thema. Fehlt aber noch.
Wenn Du einen anderen Drehpunkt haben willst, dann verschieb halt das Model in AC3D.
ich habe die datei mal geändert. es wird zu px und py der neue drehpunkt zugerechnet. dem enstprechend die funktionseingabe um diese 2 werte erweitert.
ich habe 2 ac-polyflächen, die mit einer drehpunktübergabe xdreh1,ydreh1 und xdreh2,ydreh2
funktionieren. dieser drehpunkt kann auch während des programmablaufes geändert werden für verschiedene spielanwendungen. es funktioniert auch die kollision.
nochmals ein lob an die erschaffer dieser polyfunktion.
bedienung vom beispiel mit den cursortasten , shift-l und shift-r.
ac3d-poly.gbas :
AC3D_load("test1.ac", 0)
zoom1=0.2
zoom2=0.4
xdrehp1=50
ydrehp1=50
xdrehp2=0
ydrehp2=0
phi1=0
phi2=45
WHILE TRUE
IF KEY(200) THEN my = my -3
IF KEY(208) THEN my = my +3
IF KEY(203) THEN mx = mx -3
IF KEY(205) THEN mx = mx +3
IF KEY(42) THEN INC phi1, 1
IF KEY(54) THEN DEC phi1, 1
DRAWRECT 0,0,320,240,RGB(0x80, 0x80, 0xff)
AC3D_RotoZoom(0, mx, my, phi1, zoom1,zoom1,xdrehp1,ydrehp1)
AC3D_RotoZoom(0, 100,100, phi2, zoom2,zoom2,xdrehp2,ydrehp2)
PRINT AC3D_Collision(0,mx,my,phi1,zoom1,zoom1,xdrehp1,ydrehp1, 0,100,100,phi2,zoom2,zoom2,xdrehp2,ydrehp2), 100,100
SHOWSCREEN
WENDac3d.gbas:
TYPE Tac3d_point
x
y
ENDTYPE
TYPE Tac3d_poly
pts[] AS Tac3d_point
color
transparency
ENDTYPE
TYPE Tac3d_shape
poly[] AS Tac3d_poly
ENDTYPE
GLOBAL gAc3dModl[] AS Tac3d_shape
// ----------------------------------------
// Draw an AC3D shape
// ----------------------------------------
FUNCTION AC3D_Draw: iShape, x,y,xdrehp,ydrehp
AC3D_RotoZoom(iShape, x,y, 0, 1, 1,xdrehp,ydrehp)
ENDFUNCTION
// ----------------------------------------
// Roto-Zoom-Stretch an AC3D shape
// ----------------------------------------
FUNCTION AC3D_RotoZoom: iShape, x, y, phi, scalex, scaley,xdrehp,ydrehp
LOCAL cphi = COS(phi)
LOCAL sphi = SIN(phi)
LOCAL px,py
LOCAL textur
FOREACH pol IN gAc3dModl[iShape].poly[]
ALPHAMODE pol.transparency
STARTPOLY 0
FOREACH pt IN pol.pts[]
px = pt.x*scalex+xdrehp
py = pt.y*scaley+ydrehp
POLYVECTOR x + px*cphi + py*sphi, y - px*sphi + py*cphi, 0,0,pol.color
NEXT
ENDPOLY
NEXT
ALPHAMODE 0
ENDFUNCTION
// ----------------------------------------
// collision check
// ----------------------------------------
FUNCTION AC3D_Collision: id1,x1,y1,ph1,sx1,sy1,xdrehp1,ydrehp1, id2,x2,y2,ph2,sx2,sy2,xdrehp2,ydrehp2
LOCAL c1 = COS(ph1)
LOCAL s1 = SIN(ph1)
LOCAL c2 = COS(ph2)
LOCAL s2 = SIN(ph2)
LOCAL px, py
STATIC tri1[] AS Tac3d_point, tri2[] AS Tac3d_point
IF LEN(tri1[])=0
DIM tri1[3]
DIM tri2[3]
ENDIF
LOCAL i, j
FOREACH pol IN gAc3dModl[id1].poly[]
i=0
FOREACH pt IN pol.pts[]
px = pt.x*sx1+xdrehp1
py = pt.y*sy1+ydrehp1
tri1[i].x = x1 + px*c1 + py*s1
tri1[i].y = y1 - px*s1 + py*c1
INC i, 1
// got an outer triangle
IF i=3
// inner poly's triangles
FOREACH pol IN gAc3dModl[id2].poly[]
j=0
FOREACH pt IN pol.pts[]
px = pt.x*sx2+xdrehp2
py = pt.y*sy2+ydrehp2
tri2[j].x = x2 + px*c2 + py*s2
tri2[j].y = y2 - px*s2 + py*c2
INC j, 1
// got an inner triangle
IF j=3
IF AC3D_tricol(tri1[], tri2[])
IF 0
STARTPOLY -1
POLYVECTOR tri1[0].x, tri1[0].y,0,0,0x0000ff
POLYVECTOR tri1[1].x, tri1[1].y,0,0,0x0000ff
POLYVECTOR tri1[2].x, tri1[2].y,0,0,0x0000ff
ENDPOLY
STARTPOLY -1
POLYVECTOR tri2[0].x, tri2[0].y,0,0,0xff0000
POLYVECTOR tri2[1].x, tri2[1].y,0,0,0xff0000
POLYVECTOR tri2[2].x, tri2[2].y,0,0,0xff0000
ENDPOLY
ENDIF
RETURN TRUE
ENDIF
tri2[1]=tri2[2]
j=2
ENDIF
NEXT
NEXT
// end of inner work
tri1[1]=tri1[2]
i=2
ENDIF
NEXT
NEXT
ENDFUNCTION
// ----------------------------------------
// Intersect triangle with triangle
// ----------------------------------------
FUNCTION AC3D_tricol: tri1[] AS Tac3d_point, tri2[] AS Tac3d_point
LOCAL i
STATIC Edges[] AS Tac3d_point, N AS Tac3d_point
IF LEN(Edges[])=0 THEN DIM Edges[3]
Edges[0].x = tri1[1].x-tri1[0].x
Edges[0].y = tri1[1].y-tri1[0].y
Edges[1].x = tri1[2].x-tri1[1].x
Edges[1].y = tri1[2].y-tri1[1].y
Edges[2].x = tri1[0].x-tri1[2].x
Edges[2].y = tri1[0].y-tri1[2].y
FOR i=0 TO 2
N.x = -Edges[i].y; N.y = Edges[i].x
IF AC3D_AxisSeperatePolygons(N, tri1[], tri2[]) THEN RETURN FALSE
NEXT
Edges[0].x = tri2[1].x-tri2[0].x
Edges[0].y = tri2[1].y-tri2[0].y
Edges[1].x = tri2[2].x-tri2[1].x
Edges[1].y = tri2[2].y-tri2[1].y
Edges[2].x = tri2[0].x-tri2[2].x
Edges[2].y = tri2[0].y-tri2[2].y
FOR i=0 TO 2
N.x = -Edges[i].y; N.y = Edges[i].x
IF AC3D_AxisSeperatePolygons(N, tri1[], tri2[]) THEN RETURN FALSE
NEXT
RETURN TRUE
ENDFUNCTION
@FUNCTION AC3D_AxisSeperatePolygons: N AS Tac3d_point, t1[] AS Tac3d_point, t2[] AS Tac3d_point
LOCAL mina, maxa, minb, maxb
AC3D_CalculateInterval(N, t1[], mina, maxa)
AC3D_CalculateInterval(N, t2[], minb, maxb)
IF mina > maxb OR minb > maxa THEN RETURN TRUE
RETURN FALSE
ENDFUNCTION
@FUNCTION AC3D_CalculateInterval: N AS Tac3d_point, t1[] AS Tac3d_point, BYREF fmin, BYREF fmax
LOCAL d, i
d = t1[0].x*N.x + t1[0].y*N.y
fmin=fmax=d
FOR i=1 TO 2
d = t1[i].x*N.x + t1[i].y*N.y
IF d fmin=d
ELSE
IF d>fmax THEN fmax=d
ENDIF
NEXT
ENDFUNCTION
// ----------------------------------------
// Load an AC3D file
// ----------------------------------------
FUNCTION AC3D_load: filename$, iShape
IF OPENFILE(1, filename$, TRUE)=FALSE THEN RETURN FALSE
REDIM gAc3dModl[INTEGER(1+iShape/100)*100]
DIM gAc3dModl[iShape].poly[0]
LOCAL line$, i, n
LOCAL tok$[]
LOCAL pol AS Tac3d_poly
LOCAL loc[]
LOCAL valid_poly
LOCAL mat[] AS Tac3d_poly
LOCAL verts[] AS Tac3d_point
LOCAL poly_z
LOCAL z_for_poly[]
DIM loc[3]
WHILE ENDOFFILE(1) = FALSE
READLINE 1, line$
line$=LCASE$(line$)
IF SPLITSTR(line$, tok$[], " \t") = 0 THEN CONTINUE
DEBUG line$+"\n"
SELECT tok$[0]
// material - get the colour + transparency
CASE "material"
LOCAL m AS Tac3d_poly
m.color=RGB(255,255,255)
m.transparency = 0
FOR i=1 TO LEN(tok$[])-1
IF tok$[i]="rgb"
LOCAL r,g,b
r = tok$[i+1]
g = tok$[i+2]
b = tok$[i+3]
m.color=RGB(r*255, g*255, b*255)
INC i,3
ENDIF
IF tok$[i]="trans"
m.transparency = tok$[i+1]
IF m.transparency THEN m.transparency = -m.transparency
ENDIF
NEXT
DIMPUSH mat[], m
// new object
CASE "object"
// clear location
loc[0]=0; loc[1]=0; loc[2]=0
DIM verts[0]
valid_poly=FALSE
IF tok$[1] = "poly" THEN valid_poly=TRUE
// location
CASE "loc"
loc[0]=tok$[1]; loc[1]=tok$[2]; loc[2]=tok$[3]
// material
CASE "mat"
// assign material by copying mat[]-poly over current poly
pol = mat[tok$[1]]
// vertice positions
CASE "numvert"
IF valid_poly
LOCAL pt AS Tac3d_point
n = tok$[1]
FOR i=1 TO n
READLINE 1, line$
SPLITSTR(line$, tok$[], " \t")
pt.x = loc[0]; INC pt.x, tok$[0]
pt.y =-loc[1]; DEC pt.y, tok$[1]
poly_z=loc[2]; INC poly_z, tok$[2]
// Pre-Scale x 100, to fit AC3D scaling to pixels better
pt.x = pt.x*100
pt.y = pt.y*100
DIMPUSH verts[], pt
NEXT
ENDIF
// surface description
CASE "surf"
// #need: convert hex number 0x30 from tok$[1]
// The first 4 bits (flags & 0xF) is the type (0 = polygon, 1 = closedline, 2 = line).
// surface nodes
CASE "refs"
n = tok$[1]
FOR i=1 TO n
READLINE 1, line$ // index, u, v
DIMPUSH pol.pts[], verts[ line$ ] // first number in line$=index
NEXT
// reverse if not anti-clockwise
LOCAL i,j,num, area
num = BOUNDS(pol.pts[],0)
FOR i = 0 TO num-1
j=MOD(i+1,num)
DEC area, pol.pts[i].y * pol.pts[j].x
INC area, pol.pts[i].x * pol.pts[j].y
NEXT
// must flip
IF area > 0
LOCAL pts[] AS Tac3d_point
FOR i=num-1 TO 0 STEP -1
DIMPUSH pts[], pol.pts[i]
NEXT
pol.pts[] = pts[]
ENDIF
DIMPUSH gAc3dModl[iShape].poly[], pol
DIMPUSH z_for_poly[], poly_z
DIM pol.pts[0]
ENDSELECT
WEND
// sort polys by Z value
FOR i=0 TO LEN(gAc3dModl[iShape].poly[])-2
IF z_for_poly[i] > z_for_poly[i+1]
pol = gAc3dModl[iShape].poly[i]
gAc3dModl[iShape].poly[i ] = gAc3dModl[iShape].poly[i+1]
gAc3dModl[iShape].poly[i+1] = pol
n = z_for_poly[i]
z_for_poly[i ] = z_for_poly[i+1]
z_for_poly[i+1] = n
IF i>0 THEN DEC i, 2
ENDIF
NEXT
CLOSEFILE 1
RETURN TRUE
ENDFUNCTION
Update!
Jetzt kann man in AC3D polylines machen, und die dann mit einem Sprite-"Stift" zeichnen lassen. Quasi wie bei GeometryWars oder so.
Ich flip' voll aus so cool ist das.
Kann bitte, bitte einer ein Spiel damit machen?
Bitte "Fort Apocalypse" in Stil von Saucelifter. :P
Jow ich guck mal :)
QuoteJetzt kann man in AC3D polylines machen, und die dann mit einem Sprite-"Stift" zeichnen lassen.
gut geworden, klasse.
bloss die sprite-stift-polygone sollten optisch geschlossen werden, weil die collision schon am geschlossenen aussenpolygon stattfindet. in einer sogenannten polygonschrere die nur aus 2 polylinien besteht mit einem gemeinsamen startpunkt oder einem offenen polygon , wird innen eine collision erkannt obwohl keine berührung stattfindet.
bei deinem zusätzlichen polygon zb kann man es gut erkennen mit der aussenliegenden collision.
mfg
@sechsrad
Das heißt, du machst jetzt auch ein Spiel?
Cheers
hehe der war gut :D
(http://www.orlyowl.com/upload/files/!NUB_LOL.jpg)
Das heißt, du machst jetzt auch ein Spiel?so heute gehst weiter, war gestern auf der "cebit", tolle sachen was die so bieten!
wenn du das so siehst ja, für mein atmegaboard mit serieller anbindung und dem visuellen roboter mit glbasic.
ich versuch für meine visuale robotersteuerung eine genaue darstellung zu erzielen.
dazu passt dieses polygon-projekt ganz gut
die polygone die man zusätzlich zeichnen kann, kann ich als ultraschall-darstellung nehmen und wenn die auf ein objekt auftreffen wird dieses aufgenommen und über die serielle schnittstelle dem atmegaboard gesendet zum weiteren reagieren.
QuoteDas heißt, du machst jetzt auch ein Spiel?
keine zeit, fange jetzt schon an zu sparen, das ich mir in 4 monaten den Pandora kaufen werde..freu! ich hoffe , das ihr mitziehen werdet und euch einen anschaffen werdet,damit die programmierscene heranwächs für den Pandora und nicht immer gesagt wird: ich programmiere zwar für den Pandora ,habe aber kein.
das heisst, ich werde nur meine roboterprojekte realisieren.
diese niedlichen handheld : gpx f200 und der Pandora sind doch klasse.
ein prosit auf die technik.