[Closed] Raycasting question

I’ll post my code here, I cannot figure out why some verts are miscasting

fn closestPointOnSurf surf refPos = (
	mpi = MeshProjIntersect()
	mpi.setNode surf
	mpi.build()
	
	mpi.closestFace refPos doubleSided:true
	
	closestPoint = mpi.getHitPos()
	
	return closestPoint
)

caster = pck_caster.object
target = pck_target.object

theFacesArray = #()
casterVertArray = #()
casterMissedVertArray = #()
casterMissedFaceArray = #()

rm = RayMeshGridIntersect()
rm.Initialize 30
rm.addNode target
rm.buildGrid()

targetMesh = snapshotAsMesh target
casterMesh = snapshotAsMesh caster

debugArr = #()
debug2Arr = #()
for v in 1 to casterMesh.numVerts do (
	thePos = getVert casterMesh v
	--for each vert, we need to get the closest point on the proxy surface first
	--then cast our 'proxy color info' ray from the vert to said point
	closestPos = closestPointOnSurf target thePos
	theNormal = normalize(thePos - closestPos)

	theHitsCount = rm.intersectSegment thePos closestPos true
	
	--if it does hit, then get the face index, and append it to an array
	if theHitsCount > 0 then (
		theIndex = rm.getClosestHit()
		theFace = rm.getHitFace theIndex
		append theFacesArray theFace
		append casterVertArray v
		append debugArr (theNormal)
	)
        else (
		print ("The ray " + v as string + " missed")
		append casterMissedVertArray v
		append casterMissedFaceArray v
		append debug2Arr (theNormal)
	)
)

)

Here is what I am coming up with:

The proxy object is offset in the screenshot to show both the source and proxy. The black verts are the ones that return a theHitsCount of 0.
Here are the ‘cast directions’:

Everything seems to cast in the correct direction, what in the world am I missing?

I’m not sure to totally understand what you’re trying to do… But I will try something.
Just ignore this post if it’s wrong.

You know raycast only “collide” with an object if the ray is inverse to the normal of the collided face? Culling, being on or off doesn’t change this. (At least, from what I remember it does in Max9. No clue about 2008) A ray being in the same direction as the normal of a face won’t intersect.

Little graph to explain what I mean.

Right, but I have the two sided flag set in : theHitsCount = rm.intersectSegment thePos closestPos true

Regardless, I’ve tried all sorts of things and, while the verts that work sometimes change (such as if I duplicate the proxy faces and flip their normals, IIRC), verts still seem to be casting incorrectly. This is doubly strange because, as far as I can tell, the verts that are working are working correctly (ie, they are getting exactly the color I would expect).

As for what I’m doing, at this stage I am taking the vert colors from the proxy mesh and applying them to the source/high poly mesh. I then take the vert colors and convert them to skin weights.

Edit: Gah, more strangeness. I took a plane as the ‘caster’ mesh and a plane offset along the z as the ‘proxy’ mesh, and cast… it worked fine. I then took the proxy plane, and soft-selected the middle vert to make a sort of ‘hump’- then verts that really shouldn’t have been affected (such as on the outer edge) suddenly start to miss. I must be missing something…

Edit2: So I tested doing “theNormal = getNormal casterMesh v” and then “theHitsCount = rm.intersectRay thePos theNormal true” and it colors the verts as expected (based on the vert normal).
My first guess would be my closesetPointOnSurf function is bad, but when I return the resultant ray I use to do rm.intersectSegment (original pos – closest point on surface), the result I get (in the multi-colored image above) doesn’t seem to correspond with the black verts as far as I can tell.
In fact, after more and more testing, I just have no idea why seemingly random verts are missing for no apparent reason. I’ve tested this in and out and I just cannot figure out why this is happening, cannot find any logic to it.
My most recent test involved doing a slight “Push” on the source/caster mesh to make the proxy/target mesh, then returning the ray from source vert to closest point on surface. This should be the surface normal, and in fact, it was (I had to invert it though, not sure why, but it didn’t fix the issue)… except for seemingly random verts that missed. Absolutely no idea why these damn ray casts are not hitting. It has to be something in my closestPointOnSurf function. I must be doing something wrong with it…

Actually, I never used RayMeshGridIntersect as I never got the need to.
A simple intersectRay was enough for my work so far.

So, sorry, can’t help you more than that.

I try to understand… You want to get the normal value from a low res model and apply it to the vertex color of a high res model?

Well, the first thing I would ask is… Why raycasting? Wouldn’t it give the same result by checking the distance between each faces and vertex?

Something like :

global CasterVertexPosition

fn GetSmallestDistance v1 v2 =
(
	local d1 = distance CasterVertexPosition v1[1]
	 local d2 = distance CasterVertexPosition v2[1]
	case of
	(
		(d1 > d2): -1
		(d1 < d2): 1
		default: 0
	)
)

FaceArray = #()

for i = 1 to target.faces.count do
(
	 append FaceArray #(polyOp.getFaceCenter target i, polyOp.getFaceNormal target i)
)

for i = 1 to caster.vertex.count do
(
	CasterVertexPosition = polyOp.getVert caster i
	
	SortedFaceArray = deepcopy FaceArray
	SortedFaceArray = qsort SortedFaceArray GetSmallestDistance

	 VertColor = (SortedFaceArray[1][2] * 255) as color

	 polyOp.setVertColor o 0 #{i} VertColor
)

(I wrote this in a few mins, so it has probably some errors)

I tried to keep from explaining the script more fully to try to not confuse people, but I can see that decision just caused some confusion:) So here is what I am doing.

I choose a caster mesh, which is my more detailed mesh I’m going to rig, a proxy mesh, which I choose from a library of presets and has vertex colors according to how it’d be weighted, and three bones, one for each vert color. I manipulate this proxy mesh to fit the caster mesh, set up all the assignments (caster, proxy, and bones), and run the script.

As I had it before, the script would shoot a ray from each vert on the caster mesh along its normal, and get the face it hit on the proxy and the barycentric coords. I then look up on the proxy mesh the vertex color of that ‘hit’ by using the face index and barycentric coords.

Lastly, I assign those vertex colors I just found to weighting relationships between bones (so 255 0 0 would weight completely to the Red bone, etc).

This all works right now. The only part I am changing is the ‘along its normal’ bit. I realized that, while the normal gets the correct color for regular/flatish geometry, for more detailed caster geometry it can grab a surface color that isn’t what I want (as I demonstrated in my first image). What I really want it to do is to grab the surface color (face hit and bary coords) from the point closest on the proxy mesh. Unfortunately to do this requires a legitimate closestpoint/raycasting solution, because I need to get the vertex color of the closest point using barycentric coords.

The bottom line is: what I am doing works correctly (I am getting the correct color info from the proxy mesh, and casting along the correct ray), but only on some verts (maybe half?). The only way for a vert to be black is if it doesn’t hit anything (rm.intersectSegment returns 0). These means my closest point function isn’t working on some verts/rays, I just cannot figure out why… at this point, I’d even just love ideas for what to try/debug, cause this is driving me up a wall.

Pre-edit: Posting your problems is good…
So, in the course of returning my surface normals/ray vector as a color last night I stumbled upon that my cast was inverted, though this didn’t fix the problem. However, when I was returning the cast normal, I had to do theNormal = normalize(closestPos – thePos), which, if I use that normal, it almost works (there are still one or two problems). So, intersectSegment was giving me the problem?