[Closed] Create Plane from Bounding Box

assuming it’s an editable mesh this gives the “exact” screen bounding box…

fn GetScreenBounds obj =
	(
		maxy = maxx = -99999999.0;
		miny = minx = 99999999.0;
		
		gw.setTransform(Matrix3 1);
		
		for v = 1 to obj.numverts  do
		(
			spos = gw.hTransPoint (getvert obj v);
			if spos.x > maxx then maxx = spos.x;
			if spos.x < minx then minx = spos.x;	
			if spos.y > maxy then maxy = spos.y;
			if spos.y < miny then miny = spos.y;	
		)
		[minx,maxx,maxy,miny]	
	)

Sadly I’m replacing trees so looking up many many many polygons isn’t going to work well.

I’ve also realised it’s slightly more complicated than I first thought as it isn’t quite camera space I need to do this in… I’ve got something half-working… but it’s not super accurate. It also needs to work on multiple objects too.

If you scatter some teapots of different proportions around in a circle around 0,0,0 then run this you’ll see what I mean. Ideally the plane would be tight to the bounding box if a camera was positioned at 0,0,0 and looking at it.

targetObj = Point()


fn getHierarchyBBox objs =
(
	local bMin = [1e100, 1e100, 1e100]
	local bMax = [-1e100, -1e100, -1e100]
	for n in objs do 
	(
		for i = 1 to 3 do
		(
			if n.min[i] < bMin[i] do bMin[i] = n.min[i]
			if n.max[i] > bMax[i] do bMax[i] = n.max[i]
		)
	)
	#(bMin, bMax)
)

fn buildCard obj =
(
	objs = join #() obj
	bbox = getHierarchyBBox objs
 
	select objs
	size = bbox[2] - bbox[1]

	x = (size[1] + size[2]) * 0.8

	if size[1] > size[2] then
		c = size[1]
	else
		c = size[2]

	y = (size[3] + c) * 0.75
	
	
	p = plane length:y width:x lengthsegs:1 widthsegs:1
	p.renderable = false
	--p.pos = obj.pos
	p.center = selection.center
	lookAtCnstr = LookAt_Constraint()
	lookAtCnstr.appendTarget targetObj 100
	lookAtCnstr.target_axis = 2
	lookAtCnstr.upnode_axis = 2
	lookAtCnstr.lookat_vector_length = 0.0
	
	p.rotation.controller = lookAtCnstr
	p.parent = obj
	p.name = "renderCard_" + obj.name 
)
for o in $Teapot* do buildcard o

if it’s trees does it have to be a billboard, would some “simpler” surfice ? crossing quads for example.

For this specific use case, crossing quads won’t work. The are all at a far distance and never going to see the cards from any other angle than facing. The ‘viewing point’ that they are tagetted to could in theory be very high up so the plane replacement for a tree would be a horizontal plane.

Figured it out… curious to know if I can make it any better than this…

Make a Camera001 camera and point it at a Teapot001 (link some other objects to it too) then run this.

targetCam = $Camera001
targetObj = $Teapot001
hierarchyObjs = (join #() targetObj)

function getLinePlaneIntersect p3LinePoint_1 p3LinePoint_2 rPlane  =
(
	--function to get point3 where a line defined by start and end point intersects with an infinite plane
    --thanks Enrico Gullotti
    local p3LineVector = p3LinePoint_2 - p3LinePoint_1
    local p3Vector_1 = rPlane.Pos - p3LinePoint_1

    local fNumer = dot rPlane.dir p3Vector_1
    local fDenom = dot rPlane.dir p3LineVector

    (p3LinePoint_1 + ((fNumer / fDenom) * p3LineVector))

)

fn getBoundingBoxVerts objs =
(
	--Get bounding box corners as point3 array for all objects
	vertArray = #()
	for obj in objs do
	(
	local bb = nodeGetBoundingBox obj obj.transform
		
	local bLength = (bb[2]-bb[1]).x
	local bWidth =(bb[2]-bb[1]).y 
	local bHeight = (bb[2]-bb[1]).z

	local vArray = #([bLength / 2, bWidth / 2, bHeight / 2],
	[-bLength / 2, bWidth / 2, bHeight / 2],
	[bLength / 2, -bWidth / 2, bHeight / 2],
	[bLength / 2, bWidth / 2, -bHeight / 2],
	[-bLength / 2, -bWidth / 2, bHeight / 2],
	[bLength / 2, -bWidth / 2, -bHeight / 2],
	[-bLength / 2, bWidth / 2, -bHeight / 2],
	[-bLength / 2, -bWidth / 2, -bHeight / 2]
	)

	join vertArray (for v in vArray collect (v * obj.transform + (obj.center - obj.pivot)))
)
vertArray
)

theZ = normalize (targetCam.pos-targetObj.pos)
theX = normalize (cross theZ [0,0,1] )
theY = normalize (cross theX theZ) 

card = Plane name:"Card"

card.transform = matrix3 theX theY theZ targetObj.pos

bmin = [0,0]
bmax = [0,0]

vertArray = getBoundingBoxVerts hierarchyObjs

for i = 1 to vertArray.count do
(
	local pos = ((getLinePlaneIntersect targetCam.pos (vertArray[i]) (ray card.pos card.dir)) * inverse card.transform)
	
	--get min and max point2 vals
	if pos.x < bmin.x do
		bmin.x = pos.x
	
	if pos.y < bmin.y do
		bmin.y = pos.y
	
	if pos.x > bmax.x do
		bmax.x = pos.x
	
	if pos.y > bmax.y do
		bmax.y = pos.y
) 
cardSize = -bmin + bmax

card.width = cardSize.x
card.length = cardSize.y

--offset from base objects position to center of card
offset = (bmin + bmax) / 2

in coordsys local
	card.pos += [offset.x,offset.y,0]