polygon winding with DrawPoly

BlitzMax Forums/BlitzMax Programming/polygon winding with DrawPoly

Scott Shaver (Posted 2005) [#1]

Are there any known issues with the winding of the vertexes when using DrawPoly? I've got a wierd situation where it looks like I can see through polygons that are drawn over other polygons. You kind of have to see it in action but here are some pictures. should look like this does look like this

skidracer (Posted 2005) [#2]

Wouldn't you need some sort of Z sort to draw the polygons in the correct order?

Scott Shaver (Posted 2005) [#3]

Yeah I have one, I'm drawing them back to front. I can't figure this out. in the above picture the strip in the middle shouldn't be visible. It behaves like it blends the front and back polygons together on screen but I'm using SOLIDBLEND for the mode. ' this code adapted from one of ETROMIC's (Olof Hånell) effects Strict Framework BRL.GLMax2D Import BRL.System Import BRL.Basic Import BRL.pngloader Import BRL.Retro ?Win32 SetGraphicsDriver(GLMax2DDriver()) ? Graphics 640,480,0'32,60 Const NUM_DEGREES:Int = 20 Const NUM_SECTIONS:Int = 45 Const NUM_POINTS:Int = 5 Const ROTATION_SCALE:Int = 2 'Global baseColor:Int = 2895943 Global baseColor:Int = 13412915 Const bgColor:Int = 2895943 Global cylinderWidth:Int = 150 Global XZ_SCALE:Int = cylinderWidth Shr 1 Global circle_y_step:Int = GraphicsHeight()/NUM_SECTIONS Global variation_speed:Float = 0.00021 Global cycledifference:Float = 0.022 Global fm:Float = 0.0 Global CP:CirclePlane[] = New CirclePlane[NUM_SECTIONS] Global polys:Polygon[] = New Polygon[(NUM_SECTIONS-1) * (NUM_POINTS)] For Local ip:Int = 0 Until polys.length polys[ip] = Polygon.Create() Next Global ptsZ:Int[] = New Int[polys.length] Global colors:Color[] = New Color[polys.length] For Local ic:Int = 0 Until polys.length colors[ic] = New Color Next Global order:Int[] = New Int[polys.length] setupSections() Global frames:Long = 0 Global fps:Long = 0 Global lastTime:Long = MilliSecs() SetClsColor(44,48,71) While Not KeyHit(KEY_ESCAPE) Cls ' clear the screen SetBlend(SOLIDBLEND) SetColor(255,255,255) SetAlpha(1) update() DoFPS() Flip() ' flip the buffers FlushMem() ' garbage collection Wend Type Point Field x:Float Field y:Float 'Field z:Float Method Set(x1:Float,y1:Float)',z1:Float) x=x1 y=y1 'z=z1 End Method End Type Type Polygon Field points:Point[] = New Point[4] Field c:Color = New Color Field array:Float[] = New Float[6] Function Create:Polygon() Local p:Polygon= New Polygon For Local c:Int = 0 To 3 p.points[c] = New Point Next Return p End Function Method firstPoints() 'array[0] = points[0].x 'array[1] = points[0].y 'array[2] = points[1].x 'array[3] = points[1].y 'array[4] = points[2].x 'array[5] = points[2].y array[0] = points[0].x array[1] = points[0].y array[2] = points[2].x array[3] = points[2].y array[4] = points[1].x array[5] = points[1].y End Method Method secondPoints() 'array[0] = points[2].x 'array[1] = points[2].y 'array[2] = points[3].x 'array[3] = points[3].y 'array[4] = points[0].x 'array[5] = points[0].y array[0] = points[2].x array[1] = points[2].y array[2] = points[0].x array[3] = points[0].y array[4] = points[3].x array[5] = points[3].y End Method End Type Type Color Field r:Int=255 Field g:Int=255 Field b:Int=255 Method Set(r1:Float,g1:Float,b1:Float) r=r1 g=g1 b=b1 End Method End Type Function rotPoints() Local diff:Float = 0 For Local i:Int=0 Until NUM_SECTIONS 'CP[i].rotateBy(Float(Float(ROTATION_SCALE)*Sin((fm+diff)*0.0174532925))) CP[i].rotateBy(Float(Float(ROTATION_SCALE)*Sin(fm+diff))) 'CP[i].rotateBy(.5) diff:+cycledifference fm:+variation_speed Next End Function Function update() rotPoints() Local yStep:Float = Float(GraphicsHeight()) / Float(NUM_SECTIONS-1) Local yp:Float = 0 Local xPush:Int = (GraphicsWidth() Shr 1) - (XZ_SCALE Shr 1) 'Local pts:Polygon[] = New Polygon[(NUM_SECTIONS-1) * (NUM_POINTS)] 'Local ptsZ:Int[] = New Int[polys.length] 'Local colors:Color[] = New Color[polys.length] 'Local order:Int[] = New Int[polys.length] Local n:Int = 0; Local p:Polygon; For Local i:Int=0 Until NUM_SECTIONS-1 For Local j:Int=0 Until NUM_POINTS p = polys[n]'Polygon.Create(); Local p0:Float[] = CP[i].GetPoint(j) Local p1:Float[] = CP[i].GetPoint(j+1) Local p2:Float[] = CP[i+1].GetPoint(j+1) Local p3:Float[] = CP[i+1].GetPoint(j) p.points[0].Set(Int(p0[0] + xPush +.5), Int(yp+.5)) p.points[1].Set(Int(p1[0] + xPush +.5), Int(yp+.5)) p.points[2].Set(Int(p2[0] + xPush +.5), Int(yp+yStep+.5)) p.points[3].Set(Int(p3[0] + xPush +.5), Int(yp+yStep+.5)) polys[n] = p; ptsZ[n] = Int(p0[1] + p1[1] + p2[1] + p3[1]) Shr 2 Local c:Int = Int( ptsZ[n] - XZ_SCALE ) Local base_r:Int = ((baseColor Shr 16) & 255) + c Local base_g:Int = ((baseColor Shr 8) & 255) + c Local base_b:Int = ((baseColor ) & 255) + c 'If j =2 Then ' base_r = ((bgColor Shr 16) & 255) + c ' base_g = ((bgColor Shr 8) & 255) + c ' base_b = ((bgColor ) & 255) + c 'EndIf If base_r>255 Then base_r = 255 If base_g>255 Then base_g = 255 If base_b>255 Then base_b = 255 'colors[n] = New Color colors[n].Set(base_r,base_g,base_b) n:+1 Next yp:+yStep Next order = zSort(ptsZ) SetBlend(SOLIDBLEND) SetColor(255,255,255) SetAlpha(1) Local nu:Int = order.length For Local i:Int=0 Until nu SetColor(colors[order[i]].r,colors[order[i]].g,colors[order[i]].b); polys[order[i]].firstPoints() DrawPoly(polys[order[i]].array); polys[order[i]].secondPoints() DrawPoly(polys[order[i]].array); Next End Function Function zSort:Int[](ptsZs:Int[]) Local sorted:Byte = False Local num:Int = ptsZs.length - 1 Local back:Int[] = New Int[ptsZ.length] For Local i:Int=0 Until back.length back[i] = i Next ' Rem While sorted=False sorted = True For Local i:Int=0 Until num If ptsZs[i] > ptsZs[i+1] Then Local backTemp:Int = back[i] Local tmp:Int = ptsZs[i] back[i] = back[i+1] ptsZs[i] = ptsZs[i+1] back[i+1] = backTemp ptsZs[i+1] = tmp sorted = False EndIf Next Wend 'EndRem Return back End Function Function DoFPS() SetBlend(SOLIDBLEND) SetColor(255,255,255) SetAlpha(1) DrawText "FPS: "+fps,0,0 frames:+1 If MilliSecs()-lastTime>=1000 Then fps=frames frames=0 lastTime=MilliSecs() EndIf End Function Function setupSections() Local sAngle:Float = 0 Local aStep:Float = Float(NUM_DEGREES) / Float(NUM_SECTIONS) For Local i:Int=0 Until NUM_SECTIONS CP[i] = CirclePlane.Create(NUM_POINTS, XZ_SCALE, sAngle) sAngle:+aStep Next End Function Type CirclePlane Field numPoints:Int = 0 Field rotation:Float = 0 Field degreeStep:Double = 0 Field ps:Float[,] Field psb:Float[,] Field scale:Int = 0 Const X:Int = 0 Const Z:Int = 1 Function Create:CirclePlane(pointCount:Int, scale:Int, sRotation:Float) Local cp:CirclePlane = New CirclePlane cp.numPoints = pointCount cp.rotation = Float(sRotation) cp.scale = scale cp.degreeStep = Double(360) / Double(pointCount) cp.ps = New Float[pointCount,2] cp.rot() Return cp End Function Method rotateBy(deg:Float) rotation :+ deg rot() End Method Method GetPoint:Float[](which:Int) Local back:Float[] = New Float[2] back[0] = ps[which Mod numPoints,0] back[1] = ps[which Mod numPoints,1] Return back End Method Method rot() Local ang:Double = 0 For Local i:Int=0 Until numPoints ps[i,X] = Int(Float(scale) * Cos(rotation + ang) + .5) ps[i,Z] = Int(Float(scale) * Cos(rotation + ang - (3.1416/2.0)) + Float(scale)+.5) ang:+degreeStep Next End Method End Type

skidracer (Posted 2005) [#4]

It looks like you still have some radians based maths in there, the 3.1416 at the bottom and things like cycledifference look a bit odd also... If the original code is in radians I would recomend sticking with that and add your own RADSIN() and RADCOS() functions.

Scott Shaver (Posted 2005) [#5]

Hmm, here is the original Java code. it appears to be working with degrees everywhere except when it does the sin and cos calls because java expects radians. package com.sas.specialfx.effects; import com.sas.specialfx.Main; import com.sas.specialfx.MouseController; import com.sas.specialfx.DisplayObject; import java.awt.*; import java.awt.image.*; public class EtromicEffect02 extends DisplayObject{ private VolatileImage img; private int W, H; public EtromicEffect02(String propName){ super(); W = Main.getInstance().displayWidth; H = Main.getInstance().displayHeight; // turn off the cursor the framework handle turning it back on for the next effect MouseController.setMousePointer(Main.BLANK_CURSOR_NAME, Main.getInstance()); init(); setUpdateInterval(0); } public void cleanup() { img.flush(); } public void display(Graphics g){ g.setColor(Color.black); g.fillRect(0,0,W,H); blt(g); } public void update(long currentTime){ updateImage(); rotPoints(); } private void init(){ initVolatileImage(); CP = new CirclePlane[NUM_SECTIONS]; circle_y_step = H / NUM_SECTIONS; setupSections(); } private void initVolatileImage(){ if(img==null){ img = Main.getInstance().getGraphicsConfiguration().createCompatibleVolatileImage(W, H); } } //--------------------------------------------------------------------------------------------------------------------------------- private void blt(Graphics g){ if(img.contentsLost()) initVolatileImage(); g.drawImage(img,0,0,null); } /* **************************************************************** **************************************************************** **************************************************************** **************************************************************** */ private final int NUM_DEGREES = 20; private final int NUM_SECTIONS = 45; private final int NUM_POINTS = 5; private final int ROTATION_SCALE = 2; private int baseColor = 0x2C3047; private final Color bgColor = new Color(0x2C3047); private int cylinderWidth = 150; private int XZ_SCALE = cylinderWidth >> 1; private int circle_y_step; private float variation_speed = 0.00021f;//0.00015f; private float cycledifference = 0.022f; private float fm = 0.0f; private CirclePlane CP[]; private void setupSections(){ int sAngle = 0; int aStep = NUM_DEGREES / NUM_SECTIONS; for(int i=0; i<NUM_SECTIONS; i++){ CP[i] = new CirclePlane(NUM_POINTS, XZ_SCALE, sAngle); sAngle += aStep; } } private void updateImage(){ Graphics img_g = img.getGraphics(); float yStep = (float)H / (float)(NUM_SECTIONS-1); img_g.setColor(bgColor); img_g.fillRect(0,0,W,H); float yp = 0; int xPush = (W >> 1) - (XZ_SCALE >> 1); Polygon pts[] = new Polygon[(NUM_SECTIONS-1) * (NUM_POINTS)]; int ptsZ[] = new int[pts.length]; Color colors[] = new Color[pts.length]; int order[] = new int[pts.length]; int n = 0; Polygon p; for(int i=0; i<NUM_SECTIONS-1; i++){ for(int j=0; j<NUM_POINTS; j++){ p = new Polygon(); float p0[] = CP[i].getPoint(j); //top left float p1[] = CP[i].getPoint(j+1); //top right float p2[] = CP[i+1].getPoint(j+1); //down right float p3[] = CP[i+1].getPoint(j); //down left p.addPoint(Math.round(p0[0] + xPush),Math.round(yp)); p.addPoint(Math.round(p1[0] + xPush),Math.round(yp)); p.addPoint(Math.round(p2[0] + xPush),Math.round(yp+yStep)); p.addPoint(Math.round(p3[0] + xPush),Math.round(yp+yStep)); pts[n] = p; ptsZ[n] = (int)(p0[1] + p1[1] + p2[1] + p3[1]) >> 2; int c = (int)( ptsZ[n] - XZ_SCALE ); int base_r = ((baseColor >> 16) & 0xFF) + c; int base_g = ((baseColor >> 8) & 0xFF) + c; int base_b = ((baseColor ) & 0xFF) + c; if(base_r>0xFF){ base_r = 0xFF;} if(base_g>0xFF){ base_g = 0xFF;} if(base_b>0xFF){ base_b = 0xFF;} int co_value = (base_r << 16) + (base_g<<8) + base_b; Color co = new Color(co_value); colors[n++] = co; } yp += yStep; } order = zSort(ptsZ); int nu = order.length; for(int i=0; i<nu; i++){ img_g.setColor(colors[order[i]]); img_g.fillPolygon(pts[order[i]]); } img_g.dispose(); } private int[] zSort(int ptsZ[]){ boolean sorted = false; int num = ptsZ.length - 1; int back[] = new int[ptsZ.length]; for(int i=0; i<back.length; i++){back[i] = i;} while(!sorted){ sorted = true; for(int i=0; i<num; i++){ if(ptsZ[i] > ptsZ[i+1]){ int backTemp = back[i]; int tmp = ptsZ[i]; back[i] = back[i+1]; ptsZ[i] = ptsZ[i+1]; back[i+1] = backTemp; ptsZ[i+1] = tmp; sorted = false; } } } return back; } private void rotPoints(){ float diff = 0f; for(int i=0; i<NUM_SECTIONS; i++){ CP[i].rotateBy((float)(ROTATION_SCALE*Math.sin(fm+diff))); diff += cycledifference; fm += variation_speed; } } /* **************************************************************** **************************************************************** **************************************************************** **************************************************************** */ //-------------- CirclePlane class private class CirclePlane{ private int numPoints = 0; private float rotation = 0; private double degreeStep; private float ps[][]; private float psb[][]; private int scale = 0; private final int X = 0; private final int Z = 1; CirclePlane(int numPoints, int scale, int sRotation){ this.numPoints = numPoints; this.rotation = (float)sRotation; this.scale = scale; degreeStep = 360d / (double)numPoints; ps = new float[numPoints][2]; rot(); } public void rotateBy(float deg){ rotation += deg; rot(); } private void rot(){ double ang = 0; for(int i=0; i<numPoints; i++){ ps[i][X] = Math.round(scale * Math.cos(Math.toRadians(rotation + ang))); ps[i][Z] = Math.round(scale * Math.cos(Math.toRadians(rotation + ang) - (Math.PI/2))) + scale; ang += degreeStep; } } public float[] getPoint(int which){ return ps[which % (numPoints)]; } } //---------------------- }

skidracer (Posted 2005) [#6]

so double check your radians to degrees stuff: CP[i].rotateBy(Float(Float(ROTATION_SCALE)*Sin(180*(fm+diff)/Pi))) ps[i,Z] = Int(Float(scale) * Cos(rotation + ang - 180) + Float(scale)+.5)

Floyd (Posted 2005) [#7]

The only obvious problem is 3.1416/2.0, which is clearly Pi/2 i.e. radians. Replace it with 90, the equivalent in degrees. This gives Cos(rotation + ang - 90). In fact, Cos(x - 90) and Sin(x) are the same. You may as well use Sin(rotation + ang).

Scott Shaver (Posted 2005) [#8]

Thanks guys that fixed it. :)