Sorry your browser is not supported!

remstart
    This program will test the structure of the vertex
    data produced by lock vertex data command and its
    other functions
    
    Hopefully this will create a better understanding
    to be able to create objects manually
remend

autocam off
sync rate 60
sync on
set bitmap format 21
`set display mode 1024,768,32

position camera 0,0,-20

WL_TRACE_INIT("trace.txt")

RUN_TEST1()

WL_TRACE_CLOSE()

ang=0

do
    rotate object 1,ang,ang,ang
    inc ang
    sync
loop

end


remstart
    show details for a cube and delete part of it
remend

function RUN_TEST1()
    x as float : y as float : z as float
    d as integer
    u as float : v as float
    
    make object cube 1,10
    lock vertexdata for limb 1,0
    
    ` do stuff now
    vcount=get vertexdata vertex count()
    WL_TRACE_WRITE("Vertex count 'CUBE' = "+str$(vcount))
    
    for vertex=0 to vcount-1
        x=get vertexdata position x(vertex)
        y=get vertexdata position y(vertex)
        z=get vertexdata position z(vertex)
        WL_TRACE_WRITE("Vertex : "+str$(vertex))
        WL_TRACE_WRITE("  Position - "+str$(x)+","+str$(y)+","+str$(z))
        
        x=get vertexdata normals x(vertex)
        y=get vertexdata normals y(vertex)
        z=get vertexdata normals z(vertex)
        WL_TRACE_WRITE("  Normals - "+str$(x)+","+str$(y)+","+str$(z))
        
        d=get vertexdata diffuse(vertex)
        WL_TRACE_WRITE("  Diffuse - "+hex$(d))
        
        u=get vertexdata u(vertex)
        v=get vertexdata v(vertex)
        WL_TRACE_WRITE("  UV - "+str$(u)+","+str$(v))
    next
    
    icount=get vertexdata index count()
    for index=0 to icount-1
        WL_TRACE_WRITE("Index : "+str$(index)+" - "+str$(get indexdata(index)))
    next
    
    delete mesh from vertexdata 16,23,24,35
    ` end of do stuff
    
    unlock vertexdata
endfunction


Rem ***** Included Source File *****

` Create a trace file so as I can track various parts of the program

function WL_TRACE_INIT(file$)
    global WL_TRACE_FP as integer
    c as integer : c=1
    while ( c <= 32 and file open( c ) )
        inc c
    endwhile
    if ( c <= 32 )
        WL_TRACE_FP=c
    else
        exitfunction
    endif
    if ( file exist(file$) ) then delete file file$
    open to write WL_TRACE_FP,file$
    write string WL_TRACE_FP,"Trace file created : "+get date$()+", "+get time$()
    write string WL_TRACE_FP,"File handle used : "+str$(WL_TRACE_FP)
endfunction

function WL_TRACE_CLOSE()
    write string WL_TRACE_FP,"EOF Trace file (safe program exit)"
    close file WL_TRACE_FP
endfunction

function WL_TRACE_WRITE(t$)
    write string WL_TRACE_FP,t$
endfunction

sync on
sync rate 60
sync sleep 1
autocam off

restore ObjectData
BuildObjectFromData(1)

position camera 0.0, 1.5, -5.0
point camera 0.0, 0.0, 0.0
position light 0, 0.0, 1.5, -5.0
point light 0, 0.0, 0.0, 0.0

do
   xrotate object 1, wrapvalue( object angle x(1) + 0.25 )
   yrotate object 1, wrapvalue( object angle y(1) + 0.5 )
   zrotate object 1, wrapvalue( object angle z(1) + 1.0 )

   sync
loop

function BuildObjectFromData(Object as integer)
   local Vertices as integer
   local Indices as integer
   local Diffuse as dword
   local Index as integer
   local x as float
   local y as float
   local z as float
   local nx as float
   local ny as float
   local nz as float
   local i as integer

   read Vertices
   read Indices

   make object new 1, Vertices, Indices, FVF_XYZ || FVF_NORMAL || FVF_DIFFUSE

   lock vertexdata for limb 1, 0
   for i = 0 to Vertices-1
      read x, y, z
      read nx, ny, nz
      read Diffuse
      set vertexdata position i, x, y, z
      set vertexdata normals  i, nx, ny, nz
      set vertexdata diffuse  i, Diffuse
   next
   for i = 0 to Indices-1
      read Index
      set indexdata i, Index
   next
   unlock vertexdata

endfunction



ObjectData:
data 24, 36                                  ` 24 vertices, 36 indices

` Vertex data
`     x   y   z  nx  ny  nz  diffuse
data -1, -1, -1,  0,  0, -1, 0xffffffff      ` Front face
data -1,  1, -1,  0,  0, -1, 0xff000000
data  1,  1, -1,  0,  0, -1, 0xffff0000
data  1, -1, -1,  0,  0, -1, 0xff00ff00
data -1, -1,  1,  0,  0,  1, 0xff0000ff      ` Back face
data -1,  1,  1,  0,  0,  1, 0xffffff00
data  1,  1,  1,  0,  0,  1, 0xff00ffff
data  1, -1,  1,  0,  0,  1, 0xffff00ff
data -1, -1, -1, -1,  0,  0, 0xffffffff      ` Left face
data -1,  1, -1, -1,  0,  0, 0xff000000
data -1, -1,  1, -1,  0,  0, 0xff0000ff
data -1,  1,  1, -1,  0,  0, 0xffffff00
data  1, -1, -1,  1,  0,  0, 0xff00ff00      ` Right face
data  1,  1, -1,  1,  0,  0, 0xffff0000
data  1, -1,  1,  1,  0,  0, 0xffff00ff
data  1,  1,  1,  1,  0,  0, 0xff00ffff
data -1,  1, -1,  0,  1,  0, 0xff000000      ` Top face
data  1,  1, -1,  0,  1,  0, 0xffff0000
data -1,  1,  1,  0,  1,  0, 0xffffff00
data  1,  1,  1,  0,  1,  0, 0xff00ffff
data -1, -1, -1,  0, -1,  0, 0xffffffff      ` Bottom face
data  1, -1, -1,  0, -1,  0, 0xff00ff00
data -1, -1,  1,  0, -1,  0, 0xff0000ff
data  1, -1,  1,  0, -1,  0, 0xffff00ff

` Index data
data 0, 1, 2, 0, 2, 3                        ` Front face
data 4, 6, 5, 4, 7, 6                        ` Back face
data 8, 10, 9, 9, 10, 11                     ` Left face
data 12, 13, 14, 14, 13, 15                  ` Right face
data 16, 19, 17, 16, 18, 19                  ` Top face
data 20, 21, 22, 21, 23, 22                  ` Bottom face



` FVF constants
#constant FVF_XYZ = 0x002
#constant FVF_XYZRHW = 0x004
#constant FVF_NORMAL = 0x010
#constant FVF_PSIZE = 0x020
#constant FVF_DIFFUSE = 0x040
#constant FVF_SPECULAR = 0x080
#constant FVF_TEX0 = 0x000
#constant FVF_TEX1 = 0x100
#constant FVF_TEX2 = 0x200
#constant FVF_TEX3 = 0x300
#constant FVF_TEX4 = 0x400
#constant FVF_TEX5 = 0x500
#constant FVF_TEX6 = 0x600
#constant FVF_TEX7 = 0x700
#constant FVF_TEX8 = 0x800

sync on
sync rate 60
autocam off

dot 0, 0, rgb(255, 0, 0)
get image 1, 0, 0, 1, 1

dot 0, 0, rgb(0, 255, 0)
get image 2, 0, 0, 1, 1

dot 0, 0, rgb(0, 0, 255)
get image 3, 0, 0, 1, 1

dot 0, 0, rgb(255, 255, 0)
get image 4, 0, 0, 1, 1

make object cube 1, 1.0
rotate object 1, 45.0, 0.0, 45.0
make mesh from object 1, 1
delete object 1

BEGIN NEW OBJECT

   ` Top Triangle, red
   ADD NEW LIMB 3, 0, 274, 0
   SET NEW LIMB NAME "T0"
   SET NEW LIMB TEXTURE 1
   SET NEW LIMB CULL 0

   ` Pivot limb, no mesh
   Pivot = ADD NEW LIMB()
   SET NEW LIMB NAME "Pivot"
   SET NEW LIMB OFFSET 0.0, -1.0, 0.0

   ` Middle-bottom triangle - untextured, culled
   Limb = ADD NEW LIMB(3, 0, 274, 0)
   SET NEW LIMB NAME "T1"
   SET NEW LIMB ROTATION 0.0, 180.0, 0.0
   SET NEW LIMB PARENT Pivot
   SET NEW LIMB CULL 1

   ` Right-bottom triangle, green
   ADD NEW LIMB 3, 0, 274, 0
   SET NEW LIMB NAME "T2"
   SET NEW LIMB OFFSET 1.0, 0.0, 0.2
   SET NEW LIMB TEXTURE 2
   SET NEW LIMB PARENT Limb
   SET NEW LIMB CULL 0

   ` Left-bottom triangle, blue, not affected by lights
   ADD NEW LIMB 3, 0, 274, 0
   SET NEW LIMB NAME "T3"
   SET NEW LIMB OFFSET -1.0, 0.0, -0.2
   SET NEW LIMB TEXTURE 3
   SET NEW LIMB PARENT Limb
   SET NEW LIMB CULL 0
   SET NEW LIMB TRANSPARENT 1
   SET NEW LIMB LIGHT 0

   ` Bottom cube, yellow, generated from mesh data
   ADD NEW LIMB FROM MESH 1
   SET NEW LIMB NAME "CUBE"
   SET NEW LIMB OFFSET 0.0, -1.0, 0.0
   SET NEW LIMB PARENT Limb
   SET NEW LIMB CULL 0
   SET NEW LIMB TEXTURE 4
FINISH NEW OBJECT 1

` Set vertex data for all limbs that have a name starting with 'T' (triangle)
for Limb = 0 to get limb count(1)
   lock vertexdata for limb 1, Limb

   if left$( limb name$(1, Limb), 1 ) = "T"
      set vertexdata position 0, -1.0, 0.0, 0.0
      set vertexdata normals  0, 0.0, 0.0, 1.0

      set vertexdata position 1, 1.0, 0.0, 0.0
      set vertexdata normals  1, 0.0, 0.0, 1.0

      set vertexdata position 2, 0.0, 1.0, 0.0
      set vertexdata normals  2, 0.0, 0.0, 1.0
   endif

   unlock vertexdata
next

color backdrop rgb(0, 0, 0)
move camera -4.0
move camera down 0.5

do
   set cursor 0, 0
   for i = 0 to get limb count(1)
      print i; " -> "; padright$(limb name$(1, i), 10);
      print " - Parent = "; num(get limb parent(1, i), 2);
      print   ", Child = "; num(get limb child(1, i), 2);
      print ", Sibling = "; num(get limb sibling(1, i), 2)
   next

   yrotate object 1, wrapvalue(object angle y(1) + 1.5)
   rotate limb 1, get limb by name(1, "Pivot"), 0.0, object angle y(1), 0.0
   rotate limb 1, get limb by name(1, "Cube"), 0.0, wrapvalue(object angle y(1) * -3.0), 0.0

   sync
loop

function Num(v as integer, Size as integer)
   local Result as string
   if v < 0
      Result = padleft$("*", Size)
   else
      Result = padleft$(str$(v), Size)
   endif
endfunction Result

` Vertex data
`     x   y   z  nx  ny  nz  diffuse
data -1, -1, -1,  0,  0, -1, 0xffffffff      ` Front face
data -1,  1, -1,  0,  0, -1, 0xff000000
data  1,  1, -1,  0,  0, -1, 0xffff0000
data  1, -1, -1,  0,  0, -1, 0xff00ff00
data -1, -1,  1,  0,  0,  1, 0xff0000ff      ` Back face
data -1,  1,  1,  0,  0,  1, 0xffffff00
data  1,  1,  1,  0,  0,  1, 0xff00ffff
data  1, -1,  1,  0,  0,  1, 0xffff00ff
data -1, -1, -1, -1,  0,  0, 0xffffffff      ` Left face
data -1,  1, -1, -1,  0,  0, 0xff000000
data -1, -1,  1, -1,  0,  0, 0xff0000ff
data -1,  1,  1, -1,  0,  0, 0xffffff00
data  1, -1, -1,  1,  0,  0, 0xff00ff00      ` Right face
data  1,  1, -1,  1,  0,  0, 0xffff0000
data  1, -1,  1,  1,  0,  0, 0xffff00ff
data  1,  1,  1,  1,  0,  0, 0xff00ffff
data -1,  1, -1,  0,  1,  0, 0xff000000      ` Top face
data  1,  1, -1,  0,  1,  0, 0xffff0000
data -1,  1,  1,  0,  1,  0, 0xffffff00
data  1,  1,  1,  0,  1,  0, 0xff00ffff
data -1, -1, -1,  0, -1,  0, 0xffffffff      ` Bottom face
data  1, -1, -1,  0, -1,  0, 0xff00ff00
data -1, -1,  1,  0, -1,  0, 0xff0000ff
data  1, -1,  1,  0, -1,  0, 0xffff00ff

` Index data
data 0, 1, 2, 0, 2, 3                        ` Front face
data 4, 6, 5, 4, 7, 6                        ` Back face
data 8, 10, 9, 9, 10, 11                     ` Left face
data 12, 13, 14, 14, 13, 15                  ` Right face
data 16, 19, 17, 16, 18, 19                  ` Top face
data 20, 21, 22, 21, 23, 22                  ` Bottom face

So for my shared vertices to start with, my cube:

      UTL       UTR (Upper Top Left/Right)
      *---------*
     /         /|
    / ceiling / |
UBL*---------*UBR (Upper Bottom Left/Right)
   |         |  |
   |         |  |
   |  wall   |  *LTR (Lower Top Left/Right)
   |         | /
   |         |/
LBL*---------*LBR (Lower Bottom Left/Right)

So for the vertices:
UBR =  1, 1,-1

And if the piece had an adjoining piece the normals would be:
UBR =  0, 1,-1 (cancelling out the Right face normal vector)

Probably need reversing to be shown on other sides of faces.

for group=0 to _MAP(mapID).groups-1
        ` Calculate the total faces (floor+ceiling+walls)
        fc=vg(group).cnt_floor * 6 + ( vg(group).cnt_wall * 3 )
        
        TRACE_WRITE("Group "+str$(group)+" Faces "+str$(fc)+" Vertices "+str$(vg(group).voff))
        
        vg(group).obj=FREE_OBJECT()
        
        vcnt = vg(group).voff
        
        ` Google these values
        fvf = FVF_XYZ || FVF_NORMAL || FVF_SPECULAR || FVF_TEX0 || FVF_DIFFUSE
        
        make object new vg(group).obj, vcnt, fc , fvf
        
        for x=1 to mwid-2
            for y=1 to mhgt-2
                pos=_MAP(mapID).pieces + x + y * mwid
                pc=_PCS(pos).piece
                gp=_PCS(pos).group
                
                ` NOT GOT TO THIS BIT YET!!!
                if gp=group
                    v=vg(group).voff
                    
                endif
            next
        next
    next

` Written by Green Gandalf 9 February 2009, minor edits 8 July 2011.

` Contains suggestions by CuCuMBeR, calcyman and IanM and uses some code
` written by Phaelax

set display mode desktop width(), desktop height(), 32
sync on: sync rate 0: sync

autocam off
position camera 0, 0, -300
point camera 0, 0, 0
backdrop off
draw to back

make object plain 1, 10, 10 ` complete perimeter button
color object 1, rgb(255, 0, 0)
position object 1, 150, -20, 0

dim points(1000, 2) as integer

cls rgb(64, 192, 32)
ink 0, 0
box 256, 128, 768, 640
ink rgb(0, 255, 0), 0

keyNow = 0
item = 0
complete = 0

repeat
  mx = mouseX()
  my = mouseY()
  inside = (mx>=257)*(mx<=767)*(my>=129)*(my<=639)
  if mouseclick()
    if keyNow = 0
      keyNow = 1
      if inside = 1
        drawDot(mx, my, item)
        inc item
      else
        button = pick object(mx, my, 1, 2)
        if button
          if item > 2
            ` join last point to first point
            dec item
            complete = 1
            ink rgb(255, 255, 0), 0
            line points(item, 0), points(item, 1), points(0, 0), points(0, 1)
            ` update list pointers
            points(item, 2) = 0
          endif
        endif
      endif
    endif
  else
    keyNow = 0
  endif
  sync
until complete

get image 1, 256, 128, 768, 640
save image "before.png", 1

` check whether perimeter is CW or CCW
` method reported by IanM
sum = 0
for v1 = 0 to item
  v2 = (v1 + 1) mod (item + 1) ` wrap around if necessary
  inc sum, points(v1, 0)*points(v2, 1) - points(v1, 1)*points(v2, 0)
next sum

` if sum > 0 then winding order is clockwise (CW)
` if sum < 0 then winding order is anti-clockwise (CCW)

if sum < 0
  ` reverse order of vertices so winding order is CW
  ` suggested by calcyman
  for v = 0 to item/2
    tmpX = points(v, 0)
    tmpY = points(v, 1)
    points(v, 0) = points(item-v, 0)
    points(v, 1) = points(item-v, 1)
    points(item-v, 0) = tmpX
    points(item-v, 1) = tmpY
  next v
endif

nxt = 0
counter = 1000

while points(points(points(nxt, 2), 2), 2) <> nxt and counter>0
  dec counter
  nxt1 = points(nxt, 2)
  nxt2 = points(nxt1, 2)
  if checkTriangle(points(nxt, 0), points(nxt, 1), points(nxt1, 0), points(nxt1, 1), points(nxt2, 0), points(nxt2, 1))
     if notContainPoint(nxt, nxt1, nxt2)
       ink rgb(0, 255, 255), 0
       line points(nxt, 0), points(nxt, 1), points(nxt2, 0), points(nxt2, 1)
       ` update list pointer
       points(nxt, 2) = nxt2
     endif
  endif
  nxt = points(nxt, 2)
 sync
endwhile

get image 1, 256, 128, 768, 640
save image "after.png", 1

wait key

end

function drawDot(mx, my, item)
  ink rgb(0, 255, 0), 0
  dot mx-1, my
  dot mx+1, my
  dot mx, my
  dot mx, my-1
  dot mx, my+1
  points(item, 0) = mx
  points(item, 1) = my
  points(item, 2) = item + 1 ` next item in list
  if item > 0
    ink rgb(255, 255, 0), 0
    line points(item-1,0), points(item-1,1), mx, my
  endif
endfunction

function checkTriangle(x1, y1,  x2, y2,  x3, y3)
  c = ((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1))>0
endfunction c

function notContainPoint(p0, p1, p2)
  ` tests whether or not the triangle with vertices p0, p1, p2 contains
  ` any other vertices in the current reduced perimeter
  nxt = points(p2, 2) ` the next vertex in the reduced perimeter
  while nxt <> p0
    if CX_2D_PointTriangle(points(nxt, 0), points(nxt, 1), points(p0, 0), points(p0, 1), points(p1, 0), points(p1, 1), points(p2, 0), points(p2, 1))
      exitfunction 0
    endif
    nxt = points(nxt, 2)
  endwhile
endfunction 1

`==============================================
` This function was supplied by CuCuMBeR and written by Phaelax
` with minor modifications by Green Gandalf to use integers instead of floats
` Returns 1 if point is inside triangle, 0 if not
` Point (px,py)
` triangle (x1,y1),(x2,y2),(x3,y3)
`==============================================
function CX_2D_PointTriangle(px,py, x1,y1, x2,y2, x3,y3)
   dABx = x2-x1
   dABy = y2-y1
   dBCx = x3-x2
   dBCy = y3-y2

   rem if verts are clockwise
   if (dABx*dBCy - dABy*dBCx) < 0
      if dABx*(py-y1) >= dABy*(px-x1) then exitfunction 0
      if dBCx*(py-y2) >= dBCy*(px-x2) then exitfunction 0
      if (x1-x3)*(py-y3) >= (y1-y3)*(px-x3) then exitfunction 0
   rem verts are ccw
   else
      if dABx*(py-y1) < dABy*(px-x1) then exitfunction 0
      if dBCx*(py-y2) < dBCy*(px-x2) then exitfunction 0
      if (x1-x3)*(py-y3) < (y1-y3)*(px-x3) then exitfunction 0
   endif
rem point is inside triangle
endfunction 1

->Dig out the level using the amoeba digging algorithm
->Implement a flood fill algorithm to determine the largest group
->Send a bitmap of the largest group to potrace to convert
->Read the paths into a vector and path array
->Triangulate the paths
->Convert to a 3D mesh
->Copy mesh to create the ceiling
->Creat faces along the path edges to create walls

<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
width="270px" height="270px" viewBox="0 0 270 270" 
onload="setClock()">

<!--This is a modified version from Charles McCathieNevile's code
  1. Javascript added to set the time as current
  2. Removed animation code
  3. Other minor changes -->

<script>

<![CDATA[

var xmlns="http://www.w3.org/2000/svg"

function setClock()
{
  var date = new Date()
  var h = parseInt(date.getHours())
  h = h > 12 ? h-12: h
  var m = parseInt(date.getMinutes())
  var s = parseInt(date.getSeconds())

  var second = 6*s
  var minute =(m+s/60)*6
  var hour = (h+m/60+s/3600)*30
 

  var hourHand = document.getElementById("hour")
  var minuteHand = document.getElementById("minute")
  var secondHand = document.getElementById("second")

  hourHand.setAttribute("transform","rotate("+ hour.toString() +")")
  minuteHand.setAttribute("transform","rotate("+ minute.toString() +")")
  secondHand.setAttribute("transform","rotate("+ second.toString() +")")  
}

]]>

</script>


<g transform="translate(150,150)">

  <!-- tick -->
  <g>
    <circle r="108"  fill="none" stroke-width="4" stroke="gray" />
    <circle r="97" fill="none" stroke-width="11" stroke="black" 
       stroke-dasharray="4,46.789082" transform="rotate(-1.5)" />
    <circle r="100" fill="none" stroke-width="5" stroke="black"
       stroke-dasharray="2,8.471976" transform="rotate(-.873)" />
  </g>

  <!-- hands -->
  <g id="hands" transform="rotate(180)">
   <g id="hour">
    <line stroke-width="5" y2="75" stroke-linecap="round" stroke="blue" opacity=".5" />
      <animateTransform attributeName="transform" type="rotate"
         repeatCount="indefinite" dur="12h" by="360" />
    <circle r="7" />
   </g>
   <g id="minute">
    <line stroke-width="4" y2="93" stroke-linecap="round" stroke="green" opacity=".9" />
      <animateTransform attributeName="transform" type="rotate"
         repeatCount="indefinite" dur="60min" by="360" />
    <circle r="6" fill="red"/>
   </g>
   <g id="second">
    <line stroke-width="2" y1="-20" y2="102" stroke-linecap="round" stroke="red" />
    <animateTransform attributeName="transform" type="rotate"
        repeatCount="indefinite" dur="60s" by="360" />
    <circle r="4" fill="blue"/>
   </g>
  </g>

</g>

</svg>