You are here: Home | Interactives | Shockwave3D Developer's Guide | UV Picking

UV Picking

"Picking" is the process of looking into the 3D world and getting information about the geometry that intersects a ray cast into the world. For instance, it's useful for finding out what polygons a laser beam hits, or what polygon the user just clicked. (In the case of finding where the user clicked, the system just fires a ray into the 3D world from the mouse location on the camera plane in the direction of view.)

Picking is done using the modelsUnderRay and modelsUnderLoc commands. They can either return a simple list of models, or it can return detailed information about each intersection, such as the actual point of intersection, the surface normal at the point, and the UV coordinates of the intersection.

Most of the time, it's sufficient to know which model the ray hits, but sometimes, you need to know exactly where on the model's texture the ray hits. For instance, if you are using 3D Flash Sprites, your polygons will likely have alpha-channeled areas that you don't want to register as a "hit". Or maybe you need to know where on the texture the user clicks to, say, have a monster get damaged in the head or the body.

You might think that the UV coordinates returned by the modelsUnderRay and modelsUnderLoc commands provide you with this, but they do not. The UV coordinates they return is a special UV system for mapping onto that particular triangular polygon. If you want to extract the actual texture UV coordinates, you have some math to do.

Luckily, James Newton has released code that solves exactly this problem. It takes a property list like that returned by the modelsUnderRay or modelsUnderLoc in #detailed mode, and returns the UV texture coordinate point of the intersection. You can then use getPixel on your texture to, say, find out whether the ray went through a transparent area of the texture, or do other computations.

Here's the code:

-- MAP POINT TO TEXTURE -- 
-- 
-- © October 2001, James Newton <newton@planetb.fr> 

on mMapPointToTexture(iSectList, anImage) ---------------------------- 
  -- RETURNS the point in the Bitmap member used by the texture 
  -- defined implicitly in <iSectList> 
  -- 
  -- INPUT: 
  -- <iSectList> should be a property list of the format: 
  --    [#model:             model("model name"), 
  --      #distance:         <float>, 
  --      #isectPosition: <vector>, 
  --      #isectNormal:    <vector>, 
  --      #meshID:            <integer>, 
  --      #faceID:            <integer>, 
  --      #vertices:       [<vector>, <vector>, <vector>], 
  --      #uvCoord:         [#u: <float>, #v: <float>]] 
  -- 
  -- <anImage> can be VOID, an image object, or any type of object 
  --   with width and height properties (eg: propList) 
  -- 
  -- When you use aCamera.modelsUnderLoc(aLoc, #detailed) or 
  -- aMember.modelsUnderRay(aPoint, aVector, #detailed), the result is 
  -- a linear list of lists with this format. 
  --------------------------------------------------------------------- 
  
  tModel      = iSectList. model 
  tResource = tModel. resource 
  
  isMesh = (tResource. type = #mesh ) 
  
  if not isMesh then 
    -- We need to use the mesh deform modifier to get texture data 
    if not((tModel. modifier ). getPos ( #meshdeform )) then 
      -- Add mesh deform modifier... but remember to remove it later 
      tModel. addModifier ( #meshdeform ) 
      isModified = TRUE 
    end if 
  end if 
  
  tFace         = iSectList. faceID 
  tUVCoord    = iSectList. uvCoord 
  
  -- Determine how the iSect data maps to this particular face 
  if isMesh then 
    tCoordList = tResource. textureCoordinateList 
    tFaceList   = tResource. face [tFace]. textureCoordinates 
    
  else 
    tCoordList = tModel. meshdeform . mesh [iSectList. meshID ]. textureCoordinateList 
    tFaceList   = tModel. meshdeform . mesh [iSectList. meshID ]. face [tFace] 
    if isModified then 
      -- Remove the modifier now that it has done its job 
      tModel. removeModifier ( #meshdeform ) 
    end if 
  end if 
  
  case anImage. ilk of 
    #void : 
      tWidth = 1 
      tHeight = 1 
      
    #point , #list : 
      tWidth = anImage[ 1 ] 
      tHeight = anImage[ 2 ] 
      
    #image , #rect , #propList : 
      tWidth = anImage. width 
      tHeight = anImage. height 
  end case 
  
  -- tCoordList will be a list of lists, each containing two floating- 
  -- point numbers between 0.0 and 1.0.   The first number defines the 
  -- relative horizontal position of a point in the texture, the 
  -- second number defines the relative vertical point.   The origin 
  -- point [0.0, 0.0] is in the bottom left hand corner. 
  -- 
  -- tFaceList will be a list with three integer values [a, b, c] 
  -- These values determine which entry in tCoordList is used by the 
  -- chosen face.   The first entry <a> defines the origin.   The u 
  -- value increases from <a> to <b>.   Any point on the line between 
  -- <a> and <b> will have a v value of zero.   The v value increases 
  -- from <a> to <c>.   Any point on the line between <a> and <b> will 
  -- have a v value of zero. 
  
  -- Calculate the position of the points <a>, <b> and <c> within the 
  -- Bitmap member. 
  
  tLocA = tCoordList[tFaceList[ 1 ]] -- [<float>, <float>] 
  tLocA = point (tLocA[ 1 ] * tWidth, ( 1 - tLocA[ 2 ]) * tHeight) 
  
  tLocB = tCoordList[tFaceList[ 2 ]] -- [<float>, <float>] 
  tLocB = point (tLocB[ 1 ] * tWidth, ( 1 - tLocB[ 2 ]) * tHeight) 
  
  tLocC = tCoordList[tFaceList[ 3 ]] -- [<float>, <float>] 
  tLocC = point (tLocC[ 1 ] * tWidth, ( 1 - tLocC[ 2 ]) * tHeight) 
  
  tUVector = (tLocB - tLocA) * tUVCoord.u -- actually a 2D point... 
  tVVector = (tLocC - tLocA) * tUVCoord.v -- ... rather than a vector 
  
  -- Start from the origin <a>, move first in the u direction then in 
  -- the v direction to end up at the point in the texture 
  
  return tLocA + tUVector + tVVector 
end mMapPointToTexture

Made on Mac