The absolutely enormous bug tutorial<\/h3>\n
\t\t\t\tWell, here we go. It\u2019s time for another huge tutorial. This
\n\t\t\t\tone covers DX8 cameras, lights, meshes, animated meshes, vector
\n\t\t\t\tand matrix arithmetic, a verlet physics engine, dds textures and
\n\t\t\t\talpha blending\u2026.. gasp<\/p>\n
\t\t\t\tInspiration for bugs<\/b><\/p>\n
\t\t\t\tMy inspiration for this tutorial was to build a physics engine
\n\t\t\t\tafter reading a gamasutra article by Thomas Jakobsen of IO
\n\t\t\t\tInteractive. The first actual work was to design a model for my
\n\t\t\t\tphysics entities. I was aiming for some kind of insect.<\/p>\n
<\/p>\n
![](\"images\/bugs\/image001.jpg\")
\n\t\t\t\t
\n <\/p>\n
\n\t\t\t\t![](\"images\/bugs\/image002.jpg\")
\n\t\t\t\t
\n\t\t\t\tIn the end the wasp character looked a bit complex, so I ended
\n\t\t\t\tup going for the beetle. The model was constructed using IK
\n\t\t\t\tchains to hold the various meshes together. I then key framed
\n\t\t\t\tan animation of the legs moving (in my interpretation of a bugs
\n\t\t\t\twalk).<\/p>\n
<\/p>\n
\n\t\t\t\t![](\"images\/bugs\/image003.gif\")
<\/p>\n
\n\t\t\t\tThen I made textures from a photograph of some insects.<\/p>\n
<\/p>\n
![](\"images\/bugs\/image004.jpg\")
<\/p>\n
\n\t\t\t\tThese textures where then applied to the appropriate meshes. I
\n\t\t\t\tended up simply going for a diffuse dark grey for the legs
\n\t\t\t\trather than try and map any textures.<\/p>\n
\t\t\t\tOnce that was done I used the DX SDK to convert my mesh file
\n\t\t\t\tinto a .X file.<\/p>\n
Getting started<\/h3>\n
\t\t\t\tThe good news is that Microsoft have already done a lot of hard
\n\t\t\t\twork for you creating a pretty good framework of modules and
\n\t\t\t\tclasses along with the D3DX library. Overall I found it made
\n\t\t\t\tthe experience of creating a 3D app pretty painless. Some
\n\t\t\t\texplorations of matrix math later on hurt a lot more however : )<\/p>\n
\t\t\t\tThe first step was to be able to initialise the DX8 engine and
\n\t\t\t\tdraw me some lines. The idea is that this will provide the
\n\t\t\t\t\u2018wireframe\u2019 view of all my bouncing boxes once I create the
\n\t\t\t\tphysics engine.<\/p>\n
\t\t\t\tFirst I included the files provided by MS. D3danimaition.cls,
\n\t\t\t\td3dframe.cls, d3dinit.bas, d3dmesh.cls, d3dpick.cls,
\n\t\t\t\td3dshader.bas, d3dutil.bas<\/p>\n
\t\t\t\tThen I made a form, pasted on a picture control, and added some \t\t\t\t<\/font>This gives us a texture for the vertexes of our objects \t\t\t\tFrom here added a routine to initialise the 3d stuff. Luckily \t\t\t\t<\/font>I called this routine from the Form_Load subroutine.<\/p>\n \t\t\t\tI also added a command button to the page so I could have a way \t\t\t\t<\/font>Still nothing much to see though\u2026 Against my very visual \t\t\t\tThere is heaps of \u2018interesting\u2019 literature I reviewed before \t\t\t\tMy original intention was to perform correct collision detection \t\t\t\tSo why did I choose Verlet instead of a more traditional ODE \t\t\t\tTo model real 3D objects using verlet, they are built out of <\/p>\n \n\t\t\t\tThis is the infamous box I am planning on making (could even be <\/p>\n \n\t\t\t\tRight time to see how all this hangs together (literally). \t\t\t\t<\/font>Hopefully that\u2019s surprisingly little (I was certainly \t\t\t\tThe Accumulate Forces function currently only adds gravity to \t\t\t\tThe last step is to satisfy any constraints that have been \t\t\t\tTo perform this distance manipulation I used the D3DX helper \t\t\t\tNow a restoration vector is made. This is a scaled version of \t\t\t\t \n\t\t\t\t \n\t\t\t\tI can already imagine the strained attention spans, so as a \t\t\t\tRemember that basic render loop. Well we are going to add some \t\t\t\t<\/font>Despite the slightly intimidating nature of the code, 1) 2) 3) \n\t\t\t\tYou can try out the sample program to see how it all hangs \t\t\t\tNot all graphics cards will display the point lists correctly, \t\t\t\tThe line list meanwhile should work fine, this is the sticks \n\t\t\t\t\tDownload sample code 98k<\/a> <\/p>\n We have our objects, but it\u2019s not really much of a physics \t\t\t\tThe collision detection technique I wanted to use is a plate \t\t\t\tThis becomes more difficult as you try and manage edge or point \t\t\t\tHence rather than do maths, I have cheated in a very nasty quick <\/p>\n 1) 2) 3) 4) 5) \n\t\t\t\tSo like I say, not very scientific, but try out the demo and see \t\t\t\tTo accommodate the bounding box, and the centre of mass, I added \t\t\t\t<\/font>Now we add the Detect Collisions routine to the main \t\t\t\t<\/font>And finally the actual code to detect collisions itself. \t\t\t\tThe routine checks for overlaps, and pushes each point in the <\/font><\/p>\n \n\tDownload sample code 437k<\/a><\/p>\n \n\t\t\t\t \n\t\t\t\tWell physics (even cheap replicas) is pretty cool, but I feel \t\t\t\tIt sounds like a simple thing\u2026. and in the end it was simple, \t\t\t\tThe problem is to create a matrix that will orientate (in this \t\t\t\tAfter going through all sorts of mathematical torture it became \t\t\t\tIf we consider only three points of the six, which is enough to <\/p>\n \n\t\t\t\tThe end result is a rotation matrix. We then add the \t\t\t\t<\/font>The next elements of interest is the code which actually \t\t\t\t<\/font>This loads a mesh into a frame, then the calls in the \t\t\t\tTo get some camera control I have also added a quick bit of \t\t\t\t<\/font><\/p>\n \n\t\tDownload sample code 437k<\/a><\/p>\n \n\t\t\t\t \n\t\t\t\tWell things are hotting up. We now have bouncing, colliding \t\t\t\tWe essentially cast a spherical shadow from the bugs centre of \t\t\t\t<\/font>This code sets up the \u2018quad\u2019 that is used to draw the \t\t\t\tThe blend colour intensity and size of the quad is determined by \n\tDownload sample code 442k<\/a> <\/p>\n \n\t\t\t\tTo enable us to trap the state of multiple keys, I use a key \t\t\t\t<\/font>For any key we can now check if it is currently held \t\t\t\t<\/font>The end result is that the bug moves forward in the \n\tDownload sample code 442k<\/a><\/p>\n \n\t\t\t\tHmm, I was busy trying to knock another bug off the map, and I <\/p>\n \n\t\t\t\tAs you can see from the picture, the bug stays on screen, as the \t\t\t\tIn mode 1 we move the camera around to follow the bug. It does \t\t\t\tFinally in mode 0 (first bug mode) the camera is always mounted \t\t\t\tSource code; <\/p>\n \t\t\t\t<\/font><\/p>\n
\n\t\t\t\tdeclarations. <\/p>\nPrivate Type CUSTOMVERTEX\r\n v As D3DVECTOR\r\n color As Long\r\n tu As Single\r\n tv As Single\r\nEnd Type\r\nConst D3DFVF_COLORVERTEX = (D3DFVF_XYZ Or D3DFVF_DIFFUSE Or D3DFVF_TEX1)\r\n\r\nDim m_ParticleTexture As Direct3DTexture8\r\nDim m_VertB As Direct3DVertexBuffer8\r\n\r\nDim m_Verts() As CUSTOMVERTEX\r\n<\/pre>\n
\n\t\t\t\t(a Particle texture), a vertex buffer, and a array of vertexes
\n\t\t\t\tto fill with data.<\/p>\n
\n\t\t\t\tMS already provide a bunch of stuff in the d3dinit.bas routines,
\n\t\t\t\tso it ends up fairly simple.. <\/p>\nPrivate Sub initialiseD3D()\r\n \r\n 'setup D3d\r\n m_binit = D3DUtil_Init(Picture1.hwnd, True, 0, 0, D3DDEVTYPE_HAL, Me)\r\n \r\n 'Set up some lights and camera\r\n g_lWindowWidth = Picture1.ScaleWidth\r\n g_lWindowHeight = Picture1.ScaleHeight\r\n D3DUtil_SetupDefaultScene\r\n \r\n 'position the camera\r\n D3DUtil_SetupCamera vec3(0, 60, -300), vec3(0, 60, -200), vec3(0, 1, 0)\r\n\r\n Dim v As CUSTOMVERTEX\r\n\r\n Set m_ParticleTexture = D3DUtil_CreateTexture(g_dev, App.path & "\\Particle.bmp", D3DFMT_UNKNOWN)\r\n \r\n Set m_VertB = Nothing\r\n Set m_VertB = g_dev.CreateVertexBuffer(4 * m_MaxParticles * Len(v), 0, D3DFVF_COLORVERTEX, D3DPOOL_MANAGED)\r\n \r\nEnd Sub\r\n<\/pre>\n
\n\t\t\t\tto get it all started. This is the basic DX8 render loop below.
\n\t\t\t\t<\/p>\nPrivate Sub Command1_Click()\r\n Do\r\n \r\n \r\n 'Start the Scene\r\n g_dev.BeginScene\r\n \r\n 'clear the buffer\r\n D3DUtil_ClearAll QBColor(8)\r\n \r\n\t'DO THE DRAWING HERE\u2026.\r\n\r\n 'End the scene\r\n g_dev.EndScene\r\n \r\n 'update the screen...\r\n D3DUtil_PresentAll g_focushwnd\r\n \r\n DoEvents\r\n Loop Until m_run = False\r\nEnd Sub<\/pre>\n
\n\t\t\t\tdevelopment style, the next stop is a physics simulation which
\n\t\t\t\twill be temporarily invisible!<\/p>\nBouncing Verlet boxes<\/h3>\n
\n\t\t\t\tdeciding where to go with this simulation. Some of the
\n\t\t\t\texcellent work by Chris Heckler and Jeff Lander was very useful
\n\t\t\t\tas were some more theoretical papers by Baraff, Mirtich, and
\n\t\t\t\tWitkin.<\/p>\n
\n\t\t\t\tand restoration, but I ran out of time in my busy schedule, so
\n\t\t\t\tmaybe later perhaps : )<\/p>\n
\n\t\t\t\tsolver? Well I chose it because of its simplicity and
\n\t\t\t\tstability. Using the ODE techniques you have to use integration
\n\t\t\t\tapproximations to work out what the new position of objects will
\n\t\t\t\tbe after a given timestep. In comparison Verlet implies a known
\n\t\t\t\tposition before and after the timestep, and it is the velocity
\n\t\t\t\tthat is an approximation.<\/p>\n
\n\t\t\t\tparticles with constraints. The constraints I have used are
\n\t\t\t\tsimply sticks of a given length between the particles. By
\n\t\t\t\tarranging them carefully you end up with boxes, pyramids, even
\n\t\t\t\tstick figures.<\/p>\n![](\"images\/bugs\/image006.gif\")
<\/p>\n
\n\t\t\t\tconsidered a crate). The 8 particles make up its corners, and
\n\t\t\t\t12 sticks make up its sides. However it don\u2019t hold up that well
\n\t\t\t\twith only these 12 sticks, so we need to add cross bracing\u2026 more
\n\t\t\t\tlike this.<\/p>\n![](\"images\/bugs\/image007.gif\")
<\/p>\n
\n\t\t\t\tRather than avoid the issue here is the code for the Verlet
\n\t\t\t\tintegration engine; <\/p>\n'**************************************************\r\n' RIGID BODY PHYSICS SIMULATION\r\n'**************************************************\r\n' David Brebner, Unlimited Realities (2001)\r\n'**************************************************\r\n' Modeled using particles with join\r\n' Thanks to Jakobsen, Baraff, Mirtich, Witkin, Verlet\r\n'\r\n' note : verlet fixed time integration is used in\r\n' this simulation for stablility\r\n'**************************************************\r\n\r\nPublic num_particles As Integer\r\n\r\nPublic num_join As Integer\r\nPublic join_p1(1000) As Long\r\nPublic join_p2(1000) As Long\r\nPublic join_rl(1000) As Long\r\n\r\nPublic m_curp(1000) As D3DVECTOR\r\n'position right now\r\n\r\nPublic m_oldp(1000) As D3DVECTOR\r\n'the old position\r\n\r\nPublic m_forc(1000) As D3DVECTOR\r\n'Force accumulation\r\n\r\nPublic m_grav As D3DVECTOR\r\n'Gravity\r\n\r\nPublic m_timeStep As Double\r\n'the time between integrations\r\n\r\nPublic Function TimeStep()\r\n 'this executed the requirements of the physics\r\n 'simulation for the current timestep\r\n\r\n AccumulateForces\r\n\r\n Verlet\r\n\r\n SatisfyConstraints\r\n\r\nEnd Function\r\n\r\nPrivate Function Verlet()\r\n Dim i As Integer\r\n Dim tmp As D3DVECTOR\r\n 'time to increment the positions based on the applied forces\r\n 'during the specified timestep...\r\n \r\n For i = 1 To num_particles\r\n \r\n tmp = m_curp(i)\r\n \r\n m_curp(i).x = (m_curp(i).x * 2 - m_oldp(i).x) + (m_forc(i).x * m_timeStep)\r\n m_curp(i).y = (m_curp(i).y * 2 - m_oldp(i).y) + (m_forc(i).y * m_timeStep)\r\n m_curp(i).z = (m_curp(i).z * 2 - m_oldp(i).z) + (m_forc(i).z * m_timeStep)\r\n \r\n m_oldp(i) = tmp\r\n \r\n Next\r\n\r\nEnd Function\r\n\r\nPrivate Function SatisfyConstraints()\r\n Dim delta As D3DVECTOR\r\n Dim vscale As Double\r\n Dim rl As Long\r\n \r\n 'constrain the box to the ground..\r\n For i = 1 To num_particles\r\n If m_curp(i).y < 0 Then\r\n 'we have hit the ground...\r\n m_curp(i).y = 0\r\n m_oldp(i).x = m_oldp(i).x + (m_curp(i).x - m_oldp(i).x) * 0.4\r\n m_oldp(i).z = m_oldp(i).z + (m_curp(i).z - m_oldp(i).z) * 0.4\r\n End If\r\n Next\r\n \r\n \r\n 'constrain sticks based on there length\r\n For i = 1 To num_join\r\n\r\n D3DXVec3Subtract delta, m_curp(join_p2(i)), m_curp(join_p1(i))\r\n\r\n rl = join_rl(i) * join_rl(i)\r\n vscale = rl \/ (delta.x * delta.x + delta.y * delta.y + delta.z * delta.z + rl) - 0.5\r\n \r\n D3DXVec3Scale delta, delta, vscale\r\n\r\n D3DXVec3Subtract m_curp(join_p1(i)), m_curp(join_p1(i)), delta\r\n\r\n D3DXVec3Add m_curp(join_p2(i)), m_curp(join_p2(i)), delta\r\n \r\n\r\n Next\r\n \r\n\r\n\r\n\r\nEnd Function\r\n\r\nPrivate Function AccumulateForces()\r\n Dim i As Integer\r\n 'All particles are influenced by gravity\r\n \r\n For i = 0 To num_particles\r\n \r\n m_forc(i) = m_grav\r\n \r\n Next\r\n\r\nEnd Function\r\n<\/pre>\n
\n\t\t\t\tsurprised). The main heartbeat is the Timestep function. It
\n\t\t\t\tcalls the tree helper functions in turn, AccumulateForces,
\n\t\t\t\tVerlet, SatisfyConstraints. <\/p>\n
\n\t\t\t\teach of the points. Eventually this would be used to apply
\n\t\t\t\tother external forces like explosions or wind. The Verlet
\n\t\t\t\tfunction performs a simple progressive approximation of the new
\n\t\t\t\tposition. The position is found by taking the current position,
\n\t\t\t\tadding the change in position (current – old), and finally,
\n\t\t\t\tadding the distance due to the accumulated forces. <\/p>\n
\n\t\t\t\testablished. In this case if any points are falling through the
\n\t\t\t\tfloor (y < 0). The other constraints are the \u2018sticks\u2019. These
\n\t\t\t\tconstraints are applied to ensure the distance between two
\n\t\t\t\tparticles is equal to the length of the stick.<\/p>\n
\n\t\t\t\tlibraries which have a number of vector manipulation functions
\n\t\t\t\tbuilt in. In this case I check the length of the stick by
\n\t\t\t\tfinding the delta (difference) between the two points on the
\n\t\t\t\tstick. This distance may have x, y and z components.<\/p>\n
\n\t\t\t\tthe delta vector. The scale will attempt to restore the stick
\n\t\t\t\tto its constrained length. To keep things all equal half the
\n\t\t\t\trestoration is applied to both ends of the stick. <\/p>\nBouncing Bits\u2026<\/h3>\n
\n\t\t\t\t\tDownload sample code 96k<\/a><\/p>\n![](\"images\/bugs\/image008.gif\")
<\/p>\n
\n\t\t\t\tcompromise to my sanity (and yours) here are some bouncing bits.<\/p>\n
\n\t\t\t\tguts to it. <\/p>\nPrivate Sub Command1_Click()\r\n Dim a%, cnt As Long\r\n Dim v As CUSTOMVERTEX\r\n Dim t As Long\r\n \r\n If m_run = False Then\r\n m_run = True\r\n t = GetTickCount - 10\r\n Do\r\n \r\n m_timeStep = (GetTickCount() - t) \/ 10000\r\n t = GetTickCount\r\n \r\n 'do a physics engine tick\r\n TimeStep\r\n \r\n 'Start the Scene\r\n g_dev.BeginScene\r\n \r\n 'clear the buffer\r\n D3DUtil_ClearAll QBColor(8)\r\n \r\n \r\n g_dev.SetRenderState D3DRS_ZWRITEENABLE, 1\r\n g_dev.SetRenderState D3DRS_ZENABLE, 1 'False\r\n g_dev.SetRenderState D3DRS_ALPHABLENDENABLE, 1\r\n \r\n g_dev.SetRenderState D3DRS_SRCBLEND, D3DBLEND_ONE\r\n g_dev.SetRenderState D3DRS_DESTBLEND, D3DBLEND_ONE\r\n g_dev.SetTextureStageState 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE\r\n \r\n g_dev.SetRenderState D3DRS_POINTSPRITE_ENABLE, 1 'True\r\n g_dev.SetRenderState D3DRS_POINTSCALE_ENABLE, 1\r\n \r\n g_dev.SetTexture 0, m_ParticleTexture\r\n \r\n g_dev.SetStreamSource 0, m_VertB, Len(v)\r\n g_dev.SetVertexShader D3DFVF_COLORVERTEX\r\n \r\n \r\n Dim DWFloat0 As Long\r\n Dim DWFloat1 As Long\r\n Dim DWFloatp08 As Long\r\n DWFloat0 = FtoDW(0.1)\r\n DWFloat1 = FtoDW(1)\r\n DWFloatp08 = FtoDW(5)\r\n ' Set the render states for using point sprites\r\n g_dev.SetRenderState D3DRS_POINTSIZE, DWFloatp08\r\n g_dev.SetRenderState D3DRS_POINTSIZE_MIN, DWFloat0\r\n g_dev.SetRenderState D3DRS_POINTSCALE_A, DWFloat0\r\n g_dev.SetRenderState D3DRS_POINTSCALE_B, DWFloat0\r\n g_dev.SetRenderState D3DRS_POINTSCALE_C, DWFloat1\r\n \r\n ReDim m_Verts(m_MaxParticles * 2)\r\n \r\n \r\n 'Render the corners\r\n cnt = 0\r\n For a% = 0 To num_particles - 1\r\n m_Verts(cnt).v = m_curp(a% + 1)\r\n m_Verts(cnt).color = &HFFFFFFFF\r\n cnt = cnt + 1\r\n If cnt = m_MaxParticles Then\r\n D3DVertexBuffer8SetData m_VertB, 0, Len(v) * cnt, 0, m_Verts(0)\r\n g_dev.DrawPrimitive D3DPT_POINTLIST, 0, cnt\r\n cnt = 0\r\n End If\r\n Next\r\n D3DVertexBuffer8SetData m_VertB, 0, Len(v) * cnt, 0, m_Verts(0)\r\n g_dev.DrawPrimitive D3DPT_POINTLIST, 0, cnt\r\n \r\n g_dev.SetRenderState D3DRS_POINTSPRITE_ENABLE, 0\r\n g_dev.SetRenderState D3DRS_POINTSCALE_ENABLE, 0\r\n g_dev.SetRenderState D3DRS_ALPHABLENDENABLE, 0\r\n \r\n 'Render the edges\r\n cnt = 0\r\n For a% = 0 To num_join - 1\r\n m_Verts(cnt * 2).v = m_curp(join_p1(a% + 1))\r\n m_Verts(cnt * 2).color = &HFFFFFFFF\r\n m_Verts(cnt * 2 + 1).v = m_curp(join_p2(a% + 1))\r\n m_Verts(cnt * 2 + 1).color = &HFFFFFFFF\r\n cnt = cnt + 1\r\n If cnt = m_MaxParticles Then\r\n D3DVertexBuffer8SetData m_VertB, 0, Len(v) * cnt * 2, 0, m_Verts(0)\r\n g_dev.DrawPrimitive D3DPT_LINELIST, 0, cnt * 2\r\n cnt = 0\r\n End If\r\n Next\r\n 'whats left\r\n D3DVertexBuffer8SetData m_VertB, 0, Len(v) * cnt * 2, 0, m_Verts(0)\r\n g_dev.DrawPrimitive D3DPT_LINELIST, 0, cnt * 2\r\n \r\n \r\n 'End the scene\r\n g_dev.EndScene\r\n \r\n 'update the screen...\r\n D3DUtil_PresentAll g_focushwnd\r\n \r\n \r\n DoEvents\r\n Loop Until m_run = False\r\n End If\r\nEnd Sub\r\n<\/pre>\n
\n\t\t\t\tit\u2019s really just 3 types of stuff going on. <\/p>\n
\n\t\t\t\tCalls to our physics engine.<\/font><\/p>\n
\n\t\t\t\tDX3D configuration code. This stuff sets up the render states,
\n\t\t\t\tand assigns textures to our points.<\/font><\/p>\n
\n\t\t\t\tStuffing our vertex buffers full of bouncing points from our
\n\t\t\t\tphysics simulator, and then rendering the vertex buffer
\n\t\t\t\tprimitive.<\/font><\/p>\n
\n\t\t\t\ttogether.<\/p>\n
\n\t\t\t\tbut these are little alpha globes used to mark the points at the
\n\t\t\t\tvertex of the objects.<\/p>\n
\n\t\t\t\twhich hold the objects together.\t<\/p>\nBounding Box<\/h3>\n
\n\t\t\t\tsimulation because all our objects simply bounce through each
\n\t\t\t\tother. The only collisions are currently performed with the
\n\t\t\t\tfloor!<\/p>\n
\n\t\t\t\tmethod. This essentially treats each face of an object as an
\n\t\t\t\tinfinite plate extending in all directions. Then by checking
\n\t\t\t\tfor a combination of collisions of plates between objects you
\n\t\t\t\tcan determine a collision.<\/p>\n
\n\t\t\t\tcollisions with a plate, and detecting exactly where the forces
\n\t\t\t\tshould be applied.<\/p>\n
\n\t\t\t\tand dirty way!!! We are using my patented \u2018Bounding Box
\n\t\t\t\tcollisions for the maths impared\u2019 technique.<\/p>\n
\n\t\t\t\tWe essentially figure out the biggest box that will enclose our
\n\t\t\t\tobject.<\/font><\/p>\n
\n\t\t\t\tWe check if two bounding boxes touch each other.<\/font><\/p>\n
\n\t\t\t\tWe figure out the centre of that box (our fake centre of mass)<\/font><\/p>\n
\n\t\t\t\tWe calculate the distance between the centre of mass of the two
\n\t\t\t\tobjects.<\/font><\/p>\n
\n\t\t\t\tWe repulse each other in opposite directions by a fraction of
\n\t\t\t\tthe distance (the closer they get, the more they are repulsed)<\/font><\/p>\n
\n\t\t\t\tthe boxes \u2018collide\u2019.<\/p>\n
\n\t\t\t\ta few new vectors to the body type.
\n\t\t\t\t<\/p>\nPublic Type body_type\r\n Part_Min As Long\r\n Part_Max As Long\r\n Join_Max As Long\r\n Join_Min As Long\r\n \r\n bound_min As D3DVECTOR\r\n bound_max As D3DVECTOR\r\n \r\n centre_mass As D3DVECTOR\r\n \r\n mesh As Long\r\nEnd Type\r\n<\/pre>\n
\n\t\t\t\tphysics timestep. <\/p>\nPublic Function TimeStep()\r\n 'this executed the requirements of the physics\r\n 'simulation for the current timestep\r\n\r\n AccumulateForces\r\n Verlet\r\n DetectCollisions \r\n SatisfyConstraints \r\nEnd Function\r\n<\/pre>\n
\n\t\t\t\tAs you can see it is fairly simple. Initially working out the
\n\t\t\t\tbounding box, and hence the centre of mass.<\/p>\n
\n\t\t\t\tobject away from the other by half of the collision force. The
\n\t\t\t\tcollision force is estimated from the distance of their centre
\n\t\t\t\tof masses. <\/p>\nPrivate Function DetectCollisions()\r\n 'collide with the ground...\r\n Dim i As Long\r\n Dim j As Long\r\n Dim a As Long\r\n Dim delta As D3DVECTOR\r\n \r\n For i = 1 To num_particles\r\n If m_curp(i).y < 0 Then\r\n 'we have hit the ground...\r\n m_curp(i).y = 0\r\n m_oldp(i).x = m_oldp(i).x + (m_curp(i).x - m_oldp(i).x) * 0.4\r\n m_oldp(i).z = m_oldp(i).z + (m_curp(i).z - m_oldp(i).z) * 0.4\r\n End If\r\n Next\r\n \r\n 'first precomputations\r\n For i = 0 To num_body - 1\r\n 'bounding box\r\n g_d3dx.ComputeBoundingBox m_curp(body(i).Part_Min), body(i).Part_Max - body(i).Part_Min, D3DFVF_NORMAL, _\r\nbody(i).bound_min, body(i).bound_max\r\n 'ridiculously cheap centre of mass\r\n body(i).centre_mass.x = (body(i).bound_min.x + body(i).bound_max.x) \/ 2\r\n body(i).centre_mass.y = (body(i).bound_min.y + body(i).bound_max.y) \/ 2\r\n body(i).centre_mass.z = (body(i).bound_min.z + body(i).bound_max.z) \/ 2\r\n Next\r\n \r\n 'now check all the bodies if their bounding boxes overlap...\r\n For i = 0 To num_body - 1\r\n For j = i To num_body - 1\r\n If (body(i).bound_min.x > body(j).bound_min.x And body(i).bound_min.x < body(j).bound_max.x) \r\n Or (body(i).bound_max.x > body(j).bound_min.x And body(i).bound_max.x < body(j).bound_max.x) Then\r\n If (body(i).bound_min.y > body(j).bound_min.y And body(i).bound_min.y < body(j).bound_max.y) \r\n Or (body(i).bound_max.y > body(j).bound_min.y And body(i).bound_max.y < body(j).bound_max.y) Then\r\n If (body(i).bound_min.z > body(j).bound_min.z And body(i).bound_min.z < body(j).bound_max.z) \r\n Or (body(i).bound_max.z > body(j).bound_min.z And body(i).bound_max.z < body(j).bound_max.z) Then\r\n 'we have a bounding box collision, now examine in more detail...\r\n \r\n 'super bogus for now...\r\n \r\n D3DXVec3Subtract delta, body(i).centre_mass, body(j).centre_mass\r\n D3DXVec3Scale delta, delta, 0.001\r\n 'delta.x = 0.03 \/ delta.x\r\n 'delta.y = 0.03 \/ delta.y\r\n 'delta.z = 0.03 \/ delta.z\r\n \r\n For a = body(i).Part_Min To body(i).Part_Max\r\n 'm_curp(a).x = m_curp(a).x - 5\r\n D3DXVec3Add m_curp(a), m_curp(a), delta\r\n Next\r\n For a = body(j).Part_Min To body(j).Part_Max\r\n 'm_curp(a).x = m_curp(a).x - 5\r\n D3DXVec3Subtract m_curp(a), m_curp(a), delta\r\n Next\r\n End If\r\n End If\r\n End If\r\n Next\r\n Next\r\n\r\nEnd Function\r\n<\/pre>\n
Textured Bugs<\/h3>\n
![](\"images\/bugs\/image009.jpg\")
<\/p>\n
\n\t\t\t\tthe need for some bugs. Its time to take the mesh designed at
\n\t\t\t\tthe start of the tutorial – then get it bouncing along with the
\n\t\t\t\tboxes.<\/p>\n
\n\t\t\t\tbut I spent a lot of time reading text books and looking at
\n\t\t\t\tsource code before the answer became obvious.<\/p>\n
\n\t\t\t\tcase rotate) a mesh to line up with a 6 normalised vectors
\n\t\t\t\tdescribing the corners of a box. When I say normalised, this
\n\t\t\t\tmeans they are scaled to 1, and aligned with the origin so that
\n\t\t\t\ttranslation and scaling to not mess up our maths.<\/p>\n
\n\t\t\t\tevident, slightly unbelievably, that it is exactly these vector
\n\t\t\t\tvalues that make up the matrix\u2026 as this is basically the proof
\n\t\t\t\tof a rotation matrix.<\/p>\n
\n\t\t\t\tform an axis, you can see from this diagram how they fit into
\n\t\t\t\tthe matrix.<\/p>\n![](\"images\/bugs\/image010.png\")
<\/p>\n
\n\t\t\t\ttranslation and scaling back to the matrix, and \u2018bingo\u2019 we can
\n\t\t\t\treposition our mesh aligned with the points in our physics
\n\t\t\t\tengine. <\/p>\nFor i = 0 To num_body - 1\r\n If body(i).Part_Max - body(i).Part_Min = 7 Then\r\n \r\n p1 = m_curp(body(i).Part_Min)\r\n p2 = m_curp(body(i).Part_Min + 1)\r\n p4 = m_curp(body(i).Part_Min + 3)\r\n p5 = m_curp(body(i).Part_Min + 4)\r\n \r\n D3DXVec3Subtract vx, p4, p1\r\n D3DXVec3Subtract vy, p2, p1\r\n D3DXVec3Subtract vz, p5, p1\r\n \r\n D3DXVec3Normalize vx, vx\r\n D3DXVec3Normalize vy, vy\r\n D3DXVec3Normalize vz, vz\r\n \r\n \r\n m3.m11 = vx.x\r\n m3.m12 = vx.y\r\n m3.m13 = vx.z\r\n m3.m21 = vy.x\r\n m3.m22 = vy.y\r\n m3.m23 = vy.z\r\n m3.m31 = vz.x\r\n m3.m32 = vz.y\r\n m3.m33 = vz.z\r\n m3.m44 = 1\r\n \r\n D3DXMatrixTranslation m2, m_curp(body(i).Part_Min).x, \r\n m_curp(body(i).Part_Min).y, m_curp(body(i).Part_Min).z\r\n \r\n D3DXMatrixScaling m, (join_rl(body(i).Join_Min + 1)) * 0.013, \r\n (join_rl(body(i).Join_Min)) * 0.04, (join_rl(body(i).Join_Min + 9)) * 0.015\r\n \r\n D3DXMatrixMultiply m, m, m3\r\n D3DXMatrixMultiply m, m, m2\r\n \r\n m_frame.SetMatrix m\r\n m_frame.Render g_dev\r\n End If\r\n Next\r\n<\/pre>\n
\n\t\t\t\thandles the mesh. By using the existing Microsoft mesh class
\n\t\t\t\tprovided it is reasonably easy.
\n\t\t\t\t<\/p>\n 'load our mesh...\r\n Set m_frame = New CD3DFrame\r\n m_frame.InitFromFile g_dev, App.path + "\\bug.x", Nothing, Nothing\r\n<\/pre>\n
\n\t\t\t\tmatrix mesh code above (m_frame.SetMatrix m and
\n\t\t\t\tm_frame.Render g_dev) actually do the alignment and rendering.<\/p>\n
\n\t\t\t\tcamera manipulation. You can see this here;
\n\t\t\t\t<\/p>\nPrivate Sub Picture1_MouseDown(Button As Integer, Shift As Integer, x As Single, y As Single)\r\n dwn% = True\r\n mx = x\r\n my = y\r\nEnd Sub\r\n\r\nPrivate Sub Picture1_MouseMove(Button As Integer, Shift As Integer, x As Single, y As Single)\r\n If dwn% Then\r\n ox = ox - (mx - x)\r\n oy = oy - (my - y)\r\n mx = x\r\n my = y\r\n D3DUtil_SetupCamera vec3(0, 200, (oy)), vec3((ox), 0, 0), vec3(0, 1, 0)\r\n End If\r\nEnd Sub\r\n\r\nPrivate Sub Picture1_MouseUp(Button As Integer, Shift As Integer, x As Single, y As Single)\r\n dwn% = False\r\nEnd Sub\r\n<\/pre>\n
Shadows<\/h3>\n
![](\"images\/bugs\/image012.jpg\")
<\/p>\n
\n\t\t\t\tbugs. But with our overhead light, it gets hard to see exactly
\n\t\t\t\twhere our bugs are. The idea of adding a shadow allows the user
\n\t\t\t\tto see intuitively the position of the bug when it is off the
\n\t\t\t\tground.<\/p>\n
\n\t\t\t\tmass down to the floor. The size and intensity of the shadow
\n\t\t\t\twill vary in proximity to the floor.
\n\t\t\t\t<\/p>\n'draw a shadow..\r\n Dim sz As Double\r\n Dim cl As Long\r\n ReDim m_Verts(num_body * 6)\r\n For i = 0 To num_body - 1\r\n If body(i).Part_Max - body(i).Part_Min = 7 Then 'the primitive is a cube...\r\n sz = join_rl(body(i).Join_Min + 1) \/ Log(body(i).centre_mass.y + 0.01)\r\n cl = body(i).centre_mass.y\r\n If cl < 100 Then cl = 100\r\n If cl > 255 Then cl = 255\r\n cl = RGB(cl, cl, cl)\r\n 'project the surface down the y axis...\r\n m_Verts(i * 6 + 0).v.x = body(i).centre_mass.x - sz\r\n m_Verts(i * 6 + 0).v.z = body(i).centre_mass.z - sz\r\n m_Verts(i * 6 + 0).v.y = 1\r\n m_Verts(i * 6 + 0).n.y = 1\r\n m_Verts(i * 6 + 0).tu = 0\r\n m_Verts(i * 6 + 0).tv = 0\r\n m_Verts(i * 6 + 0).color = cl\r\n\r\n m_Verts(i * 6 + 1).v.x = body(i).centre_mass.x - sz\r\n m_Verts(i * 6 + 1).v.z = body(i).centre_mass.z + sz\r\n m_Verts(i * 6 + 1).v.y = 1\r\n m_Verts(i * 6 + 1).n.y = 1\r\n m_Verts(i * 6 + 1).tu = 0\r\n m_Verts(i * 6 + 1).tv = 1\r\n m_Verts(i * 6 + 1).color = cl\r\n\r\n m_Verts(i * 6 + 2).v.x = body(i).centre_mass.x + sz\r\n m_Verts(i * 6 + 2).v.z = body(i).centre_mass.z + sz\r\n m_Verts(i * 6 + 2).v.y = 1\r\n m_Verts(i * 6 + 2).n.y = 1\r\n m_Verts(i * 6 + 2).tu = 1\r\n m_Verts(i * 6 + 2).tv = 1\r\n m_Verts(i * 6 + 2).color = cl\r\n\r\n m_Verts(i * 6 + 3).v.x = body(i).centre_mass.x - sz\r\n m_Verts(i * 6 + 3).v.z = body(i).centre_mass.z - sz\r\n m_Verts(i * 6 + 3).v.y = 1\r\n m_Verts(i * 6 + 3).n.y = 1\r\n m_Verts(i * 6 + 3).tu = 0\r\n m_Verts(i * 6 + 3).tv = 0\r\n m_Verts(i * 6 + 3).color = cl\r\n\r\n m_Verts(i * 6 + 4).v.x = body(i).centre_mass.x + sz\r\n m_Verts(i * 6 + 4).v.z = body(i).centre_mass.z + sz\r\n m_Verts(i * 6 + 4).v.y = 1\r\n m_Verts(i * 6 + 4).n.y = 1\r\n m_Verts(i * 6 + 4).tu = 1\r\n m_Verts(i * 6 + 4).tv = 1\r\n m_Verts(i * 6 + 4).color = cl\r\n\r\n m_Verts(i * 6 + 5).v.x = body(i).centre_mass.x + sz\r\n m_Verts(i * 6 + 5).v.z = body(i).centre_mass.z - sz\r\n m_Verts(i * 6 + 5).v.y = 1\r\n m_Verts(i * 6 + 5).n.y = 1\r\n m_Verts(i * 6 + 5).tu = 1\r\n m_Verts(i * 6 + 5).tv = 0\r\n m_Verts(i * 6 + 5).color = cl\r\n End If\r\n Next\r\n \r\n g_dev.SetTexture 0, m_ShadowTexture\r\n g_dev.SetRenderState D3DRS_ALPHABLENDENABLE, 1\r\n g_dev.SetTextureStageState 0, D3DTSS_ALPHAOP, D3DTOP_SUBTRACT\r\n g_dev.SetRenderState D3DRS_SRCBLEND, D3DBLEND_SRCALPHA\r\n g_dev.SetRenderState D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA\r\n g_dev.SetVertexShader D3DFVF_COLORVERTEX\r\n g_dev.SetStreamSource 0, m_VertB, Len(v)\r\n D3DVertexBuffer8SetData m_VertB, 0, Len(v) * (num_body) * 6, 0, m_Verts(0)\r\n g_dev.DrawPrimitive D3DPT_TRIANGLELIST, 0, (num_body) * 2\r\n<\/pre>\n
\n\t\t\t\tshadow. A quad is simply two triangles that are next to each
\n\t\t\t\tother to form a square (4 corners = quad).<\/p>\n
\n\t\t\t\tthe proximity to the ground.<\/p>\nDriving<\/h3>\n
\n
\n\t\t\t\tIt\u2019s time to get control of our bugs. There is no fun in a
\n\t\t\t\ttotally passive simulation. We want to drive our bugs around
\n\t\t\t\tour scene to test out our collision algorithms.<\/p>\n![](\"images\/bugs\/image013.jpg\")
<\/p>\n
\n\t\t\t\tarray state trick. This works like this;
\n\t\t\t\t<\/p>\n
\n\t\t\t\tdown. The code that the bug actually responds to is in the
\n\t\t\t\tcheck_keys routines. It looks something like this;
\n\t\t\t\t<\/p>\nPrivate Sub check_keys()\r\n Dim v As D3DVECTOR\r\n Dim v2 As D3DVECTOR\r\n Dim m As D3DMATRIX\r\n Dim k As Long\r\n If keyarray(vbKeyLeft) Then\r\n D3DXMatrixIdentity m\r\n D3DXMatrixRotationY m, -10 * m_timeStep\r\n For k = 1 To 88\r\n D3DXVec3Subtract v, m_curp(k), body(0).centre_mass\r\n 'v is now relative to the centre of the box\r\n D3DXVec3TransformNormal v, v, m\r\n 'now put it back\r\n D3DXVec3Add m_curp(k), v, body(0).centre_mass\r\n 'update the old particle position\r\n m_oldp(k).x = m_curp(k).x\r\n m_oldp(k).z = m_curp(k).z\r\n Next\r\n End If\r\n If keyarray(vbKeyRight) Then\r\n D3DXMatrixIdentity m\r\n D3DXMatrixRotationY m, 10 * m_timeStep\r\n For k = 1 To 8\r\n D3DXVec3Subtract v, m_curp(k), body(0).centre_mass\r\n 'v is now relative to the centre of the box\r\n D3DXVec3TransformNormal v, v, m\r\n 'now put it back\r\n D3DXVec3Add m_curp(k), v, body(0).centre_mass\r\n m_oldp(k) = m_curp(k)\r\n Next\r\n End If\r\n If keyarray(vbKeyUp) Then\r\n D3DXVec3Subtract v, m_curp(5), m_curp(1)\r\n D3DXVec3Scale v2, v, -19.9 * m_timeStep\r\n D3DXVec3Scale v, v, -20 * m_timeStep\r\n v.y = 0\r\n v2.y = 0\r\n If m_curp(1).y > m_curp(2).y Then\r\n 'whoops upside down..\r\n m_curp(1).y = m_curp(1).y + (m_curp(1).y - m_curp(2).y) \/ 50\r\n m_curp(4).y = m_curp(4).y + (m_curp(1).y - m_curp(2).y) \/ 50\r\n End If\r\n For k = 1 To 8\r\n D3DXVec3Add m_curp(k), m_curp(k), v\r\n D3DXVec3Add m_oldp(k), m_oldp(k), v2\r\n Next\r\n End If\r\n If keyarray(vbKeyDown) Then\r\n D3DXVec3Subtract v, m_curp(5), m_curp(1)\r\n D3DXVec3Scale v2, v, 19.9 * m_timeStep\r\n D3DXVec3Scale v, v, 20 * m_timeStep\r\n v.y = 0\r\n v2.y = 0\r\n For k = 1 To 8\r\n D3DXVec3Add m_curp(k), m_curp(k), v\r\n D3DXVec3Add m_oldp(k), m_oldp(k), v2\r\n Next\r\n End If\r\nEnd Sub\r\n<\/pre>\n
\n\t\t\t\tdirection the bug is pointing. Pressing the right or left keys
\n\t\t\t\twill rotate the bug slightly in that direction.<\/p>\nCamera<\/h3>\n
\n\t\t\t\tran off-screen. It\u2019s hard to control your bug when you can\u2019t
\n\t\t\t\tsee it. Definitely time to add camera control.<\/p>\n![](\"images\/bugs\/image014.jpg\")
<\/p>\n
\n\t\t\t\trest of the scene moves around.
\n\t\t\t\tIn-fact we ended up with 3 camera modes. This one is
\n\t\t\t\tcamera_mode 2, the far away camera that pans to follow our bug.
\n\t\t\t\tThis is possibly the simplist. We calculate the vector between
\n\t\t\t\tthe distant camera and the bug, and then point the camera in
\n\t\t\t\tthat direction.<\/p>\n
\n\t\t\t\tthis with a slight delay. This way the camera essentially drags
\n\t\t\t\talong behind the bug.<\/p>\n
\n\t\t\t\ton the front of our bugs antennae. The hardest part of this was
\n\t\t\t\tfinding a small enough camera.<\/p>\n 'position the camera\r\n If camera_mode = 0 Then\r\n 'first bug mode...\r\n D3DXVec3Subtract vec, m_curp(4), m_curp(1)\r\n D3DXVec3Scale vec, vec, 0.5\r\n D3DXVec3Add vec_to, m_curp(6), vec\r\n D3DXVec3Add vec_from, m_curp(2), vec\r\n D3DUtil_SetupCamera vec_to, vec_from, vec3(0, 1, 0)\r\n ElseIf camera_mode = 1 Then\r\n '3rd bug mode\r\n D3DXVec3Subtract vec, vec_from, body(0).centre_mass\r\n D3DXVec3Scale vec, vec, 0.25\r\n D3DXVec3Subtract vec_to, vec_from, vec\r\n \r\n D3DUtil_SetupCamera vec_from, vec_to, vec3(0, 1, 0)\r\n \r\n 'animate the vec_from...\r\n D3DXVec3Normalize vec, vec\r\n D3DXVec3Scale vec, vec, 60\r\n D3DXVec3Add vec, body(0).centre_mass, vec\r\n vec.y = vec.y + 25\r\n \r\n D3DXVec3Lerp vec_from, vec_from, vec, 0.02\r\n ElseIf camera_mode = 2 Then\r\n 'far away camera...\r\n vec_from = vec3(0, 120, -400)\r\n \r\n D3DXVec3Subtract vec, vec_from, body(0).centre_mass\r\n D3DXVec3Scale vec, vec, 0.25\r\n D3DXVec3Subtract vec_to, vec_from, vec\r\n \r\n D3DUtil_SetupCamera vec_from, vec_to, vec3(0, 1, 0)\r\n End If\r\n<\/pre>\n
Animation<\/h3>\n
![](\"images\/bugs\/image015.jpg\")
<\/p>\n![](\"images\/bugs\/image016.jpg\")
<\/p>\n