Ray Casting(Wolfenstein style)

BlitzMax Forums/BlitzMax Programming/Ray Casting(Wolfenstein style)

Yahfree (Posted 2011) [#1]

Hey, I'm working on a raycaster for psuedo 3d.. and I seem to have something SERIOUSLY wrong with my math. Graphics 640,320 New TGame End Type TGame Field quit:Int Field cam:TCamera Method New() quit = False cam = New TCamera cam.Init(60,320,160) Run() End Method Method Run() While Not quit Cls Logic() Render() Flip 1 Wend End Method Method Logic() If KeyHit(KEY_ESCAPE) quit = True cam.Update() End Method Method Render() Render2DScreen() End Method Method Render2DScreen() SetColor 100,100,100 DrawRect 0,0,16*TLevel.levelW,16*TLevel.levelH SetColor 255,255,255 Local currentblock:Int For Local _yi:Int = 0 To TLevel.levelH-1 For Local _xi:Int = 0 To TLevel.levelW-1 'Print currentblock currentblock = (_yi*(TLevel.levelW))+_xi 'Print currentblock SetColor 255,255,255 For Local r:TRay = EachIn cam.rayList If r.hitIndex = currentblock SetColor 255,0,0 Exit Next If TLevel.levelData[currentblock] = 1 DrawRect _xi*16,_yi*16,16,16 Next Next SetColor 255,0,0 DrawOval cam.x/4,cam.y/4,10,10 DrawLine (cam.x/4)+5,(cam.y/4)+5,((cam.x/4)+5)+(Cos(cam.rot)*20),((cam.y/4)+5)+(Sin(cam.rot)*20) DrawLine (cam.x/4)+5,(cam.y/4)+5,((cam.x/4)+5)+(Cos(cam.rot-(cam.fov/2))*40),((cam.y/4)+5)+(Sin(cam.rot-(cam.fov/2))*40) DrawLine (cam.x/4)+5,(cam.y/4)+5,((cam.x/4)+5)+(Cos(cam.rot+(cam.fov/2))*40),((cam.y/4)+5)+(Sin(cam.rot+(cam.fov/2))*40) SetColor 255,255,255 'DrawText "X: "+Floor(cam.x/TLevel.blockDim)+" Y: "+Floor(cam.y/TLevel.blockDim),0,200 DrawText "rot "+cam.rot,0,200 End Method End Type Type TLevel Global blockDim:Int = 64 Global levelW:Int = 11 Global levelH:Int = 9 Global levelData:Int[] = [1,1,1,1,1,1,1,1,1,1,1,.. 1,0,0,0,0,1,0,0,0,0,1,.. 1,0,0,0,0,1,0,0,0,0,1,.. 1,0,0,0,0,0,0,0,0,0,1,.. 1,0,0,0,0,0,0,0,0,0,1,.. 1,0,0,0,0,0,0,0,0,0,1,.. 1,0,0,0,0,0,0,0,0,0,1,.. 1,0,0,0,0,0,0,0,0,0,1,.. 1,1,1,1,1,1,1,1,1,1,1] Function xGridtoReal:Float(x:Int) Return x*blockDim End Function Function yGridtoReal:Float(y:Int) Return y*blockDim End Function Function xyToGridIndex:Int(x:Float,y:Float) Return (Floor(y/blockDim)*levelW)+Floor(x/blockDim) End Function End Type Type TCamera Field fov:Int Field width:Int Field height:Int Field rayList:TList Field rayStep:Float Field x:Float,y:Float Field rot:Int Method New() rayList = CreateList() x = 100 y = 100 End Method Method Init(_fov:Int,w:Int,h:Int) fov = _fov width = w height = h rayStep = Float(fov)/Float(width) Print rayStep For Local i:Int = 0 To width-1 Local r:TRay = New TRay r.column = i r.deltaTheta = i*rayStep ListAddLast(rayList,r) Next End Method Method CastRays() Local startangle:Float = rot-(fov/2) For r:TRay = EachIn rayList r.Cast(x,y,startangle) Next End Method Method Update() If KeyDown(KEY_LEFT) rot:-1 CastRays() If KeyDown(KEY_RIGHT) rot:+1 CastRays() If KeyDown(KEY_UP) testx = x+3*Cos(rot) testy = y+3*Sin(rot) Local suggestedblock:Int = TLevel.xyToGridIndex(testx,testy) Print suggestedblock If TLevel.levelData[suggestedblock] = 0 x=testx y=testy End If CastRays() End If rot = rot Mod 360 If rot < 0 rot = 360+rot End Method Method Render() End Method End Type Type TRay Field column:Int Field deltaTheta:Float Field hitType:Int Field hitDistance:Float Field hitIndex:Int = -1 Method Cast(x:Float,y:Float,startangle:Float) 'flip the angle.. IE.. clockwise is declining, and counterclockwise is inclining Local angle:Float = startangle+deltaTheta angle = 360-angle angle = angle Mod 360 If angle < 0 angle = 360+angle 'Print angle Local ay:Float'first intersection y Local ax:Float'first intersection x Local ya:Float'delta y between the next intersection Local xa:Float'delta x between the next intersection Local horizontalhit:Int = False Local horizontaldistance:Float 'distance to the hit(horizontal check) Local verticalhit:Int = False Local verticaldistance:Float 'distance to the hit(vertical check) 'HORIZONTAL COLLISIONS If angle > 0 And angle < 180'facing up ay = Floor(y/TLevel.blockDim)*TLevel.blockDim-1 ax = x + ((y-ay)/Tan(angle)) ya = -TLevel.blockDim xa = TLevel.blockDim/Tan(angle) Else 'facing down ay = Floor(y/TLevel.blockDim)*TLevel.blockDim+TLevel.blockDim ax = x + ((y-ay)/Tan(angle)) ya = TLevel.blockDim xa = TLevel.blockDim/Tan(angle) End If 'Print "AX: "+Floor(ax/64)+" AY: "+Floor(ay/64)+" GRID INDEX: "+TLevel.xyToGridIndex(ax,ay) If(TLevel.xyToGridIndex(ax,ay) <= Len(TLevel.levelData)-1 And TLevel.xyToGridIndex(ax,ay)>-1) If TLevel.levelData[TLevel.xyToGridIndex(ax,ay)] <> 0 horizontaldistance = Abs(x - ax)/Cos(angle) horizontalhit = True hitIndex = TLevel.xyToGridIndex(ax,ay) Else Local checkX:Float = ax + xa Local checkY:Float = ay + ya While Not horizontalhit If TLevel.xyToGridIndex(checkX,checkY) < 0 Or TLevel.xyToGridIndex(checkX,checkY) > Len(TLevel.levelData)-1 'Print "no hit" Exit Else If TLevel.levelData[TLevel.xyToGridIndex(checkX,checkY)] <> 0 horizontalhit = True horizontaldistance = Abs(x - checkX)/Cos(angle) hitIndex = TLevel.xyToGridIndex(checkX,checkY) End If End If checkX:+xa checkY:+ya Wend End If End If 'VERTICAL COLLISIONS COMING SOON Rem If (angle > 0 And angle < 90) Or (angle > 270 And angle < 360) ' right ax = Floor(x/TLevel.blockDim)*TLevel.blockDim+TLevel.blockDim ay = y + ((x - ax)*Tan(angle)) ya = TLevel.blockDim*Tan(angle) xa = TLevel.blockDim Else ' left ax = Floor(x/TLevel.blockDim)*TLevel.blockDim-1 ay = y + ((x - ax)*Tan(angle)) ya = TLevel.blockDim*Tan(angle) xa = -TLevel.blockDim End If End Rem End Method End Type Can anyone with experience with this sort of thing give me some pointers? I'm trying to follow this guide: http://www.permadi.com/tutorial/raycast/rayc8.html my code should highlight the walls in RED that are hit by rays.. though it seems to be really random and weird!

xlsior (Posted 2011) [#2]

No idea and I haven't looked at the code you posted, but just in case: A common issue people run into is that Blitzmax trigonometry functions (cos, sin, tan, etc.) use degrees instead of radians. Just something to keep in mind, especially if you are getting unexpected results.

Yahfree (Posted 2011) [#3]

I'm pretty sure it has to do with the tracing code.. When I just run tracing to the first point(ax,ay) it finds the correct first point.. However when I increment the first point by xa, and ya respectively, it seems to be tracing in the wrong direction or something. The tutorial I'm following ( http://www.permadi.com/tutorial/raycast/rayc8.html ) seems to just say general things such as "the tangent of alpha".. so I don't think it's a problem with angles.. the tangent of PI should be equal to the tangent of 180 degrees, no?

xlsior (Posted 2011) [#4]

tangent in degrees is different than a tangent in radians...

Noobody (Posted 2011) [#5]

I had a quick glance over your code and the main issue I see is that you didn't implement vertical collision. Horizontal collision seems to work quite good, even though the ray angles are a bit off compared to what is drawn. Although, in my opinion, the method proposed on that site seems way more complicated and inefficient than it should be. Instead of artificially splitting the raymarching process into horizontal and vertical steps and then taking the solution that is closer, why not do both at once? This is what is known as a DDA algorithm; here's a quick raycasting demonstration of how it works: SuperStrict Const GWIDTH:Int = 800 Const GHEIGHT:Int = 600 SetGraphicsDriver GLMax2DDriver() Graphics GWIDTH, GHEIGHT Global FPSTimer:Int = MilliSecs(), FPSCounter:Int, FPS:Int Local Cam:TCamera = New TCamera Local Pixmap:TPixmap = CreatePixmap(GWIDTH, GHEIGHT, PF_BGRA8888) Local Timer:TTimer = CreateTimer(60) While Not (KeyHit(KEY_ESCAPE) Or AppTerminate()) Cls Cam.Update() Cam.Render(Pixmap) DrawPixmap Pixmap, 0, 0 DrawText "FPS: " + GetFPS(), 0, 0 Flip 0 WaitTimer Timer Wend End Function GetFPS:Int() FPSCounter :+ 1 If MilliSecs() - FPSTimer > 1000 Then FPS = FPSCounter FPSCounter = 0 FPSTimer = MilliSecs() EndIf Return FPS End Function Type TCamera Field AOV:Float Field PositionX:Float Field PositionY:Float Field Angle:Float Field Map:Int[][] Field ColorTable:Int[] Method New() AOV = 60.0 Angle = 90.0 PositionX = 5.0 PositionY = 8.0 Map = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 5, 0, 3, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 5, 0, 3, 0, 0, 2, 2, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1], .. [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], .. [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ColorTable = [$FFFFFF, $FF0000, $00FF00, $FFFF00, $CCCCFF, $FFCC22] End Method Method Update() Local NewX:Float = PositionX + (KeyDown(KEY_UP) - KeyDown(KEY_DOWN))*0.1*Cos(Angle) Local NewY:Float = PositionY - (KeyDown(KEY_UP) - KeyDown(KEY_DOWN))*0.1*Sin(Angle) If Not Map[Int(PositionY)][Int(NewX)] Then PositionX = NewX If Not Map[Int(NewY)][Int(PositionX)] Then PositionY = NewY Angle :+ KeyDown(KEY_RIGHT) - KeyDown(KEY_LEFT) End Method Method Render(Pixmap:TPixmap) Pixmap.ClearPixels(0) Local Width:Int = Pixmap.Width Local Height:Int = Pixmap.Height Local MapWidth:Int = Map[0].Length Local MapHeight:Int = Map.Length Local TileX:Int = Floor(PositionX) Local TileY:Int = Floor(PositionY) Local PlaneDistance:Float = Width*0.5/Tan(AOV*0.5) Local AngleStep:Float = AOV/Width Local RayAngle:Float = Angle - AOV*0.5 Local PixelPointer:Int Ptr = Int Ptr Pixmap.PixelPtr(0, 0) For Local I:Int = 0 Until Width Local DirX:Float = Cos(RayAngle) Local DirY:Float = -Sin(RayAngle) Local StepX:Int = Sgn(DirX) Local StepY:Int = Sgn(DirY) Local dTX:Float = Abs(1.0/DirX) Local dTY:Float = Abs(1.0/DirY) Local MinTX:Float, MinTY:Float If StepX = -1 Then MinTX = (PositionX - TileX)*dTX Else MinTX = (TileX + 1.0 - PositionX)*dTX If StepY = -1 Then MinTY = (PositionY - TileY)*dTY Else MinTY = (TileY + 1.0 - PositionY)*dTY Local RayX:Int = TileX Local RayY:Int = TileY Local Distance:Float While RayX >= 0 And RayY >= 0 And RayX < MapWidth And RayY < MapHeight If Map[RayY][RayX] Then Local WallHeight:Float = PlaneDistance/(Distance*Cos(RayAngle - Angle)) Local Color:Int = ColorTable[Map[RayY][RayX] - 1] Local Pixel:Int Ptr = PixelPointer + Max(Int((Height - WallHeight)*0.5), 0)*Width For Local Y:Int = 0 Until Min(WallHeight, Height) Pixel[I] = Color Pixel :+ Width Next Exit EndIf If MinTX < MinTY Then RayX :+ StepX Distance = MinTX MinTX :+ dTX Else RayY :+ StepY Distance = MinTY MinTY :+ dTY EndIf Wend RayAngle :+ AngleStep Next End Method End Type This paper gives a nice explanation of how it works (just ignore the voxel and raytracing talk and skip right to the two dimensional case).

Jesse (Posted 2011) [#6]

it is true, the tutorial uses degrees. the problem I believe is that the tutorial uses counter clockwise angle increment while BlitzMax uses clockwise angle increment.