- Home /
GameObject width in screen space
Hi there Uniteers o/ I am in need of some help. I am trying to get the width (and possibly height) of an object, when it has been rendered (Screen space).
My initial thought would be to access all vertices in the model, and use WorldToScreenPoint(); on each vertice position, followed by iterating through them to see which of the vertices have the highest/lowest x values. To me, this sounds very computational heavy, and I am sure there is a more efficient way than that.
Anyone have an idea?
Well you could call GetBounds on the renderer and then you'd only have 8 points to consider... Less accurate though. Especially as the result is an AABB.
Well, that clearly is an approach that could work, and I actually think it yields the necessary information I need. I'll sit tight and see if others have some great ideas.
I am in the middle of trying to implement this, though I am having some issues. I'll post a solution if I find one.
Answer by Freaking-Pingo · Nov 23, 2012 at 08:02 PM
Okay I'll go ahead and answer my own post: I made an attempt as "Whydoidoit" suggested
Find the desired GameObject you wish to measure
Identify its boundries
Identify the eight coordinates which forms the boundries
Convert these eight coordinates into Screen space coordinates
Locate the max/min values
Find the distance between max/min and you will get Width/Height
The output of it works fine when the object is properly fitted inside the viewport, but as soon the object begins to wander out of screen, the width and height goes crazy. The exact reason for that I don't know, I presume it is because of the shape of the camera.
I posted the example code which I tried out, hope it might be useful for someone else.
private void FindCenterOnScreen(){
_TargetPosition = camera.WorldToScreenPoint(_Target.transform.position);
_TargetPosition.y = Screen.height-_TargetPosition.y;
}
// Don't be fooled by the method name, it also calculates height.
private float FindWidthInScreen(GameObject _TargetGameObject){
Vector2 _ObjectScreenCord, _Xmin = new Vector2(Screen.width,0), _Xmax = Vector2.zero, _Ymin = new Vector2(Screen.height,0), _Ymax = Vector2.zero;
float _Height, _Width;
for(int i = 0; i != 8; i++){
//FindBoundCord() locates the eight coordinates that forms the boundries, followed by converting the coordinates to screen space.
// The entire script starts in FindBoundCord
_ObjectScreenCord = camera.WorldToScreenPoint(FindBoundCord(i, _TargetGameObject));
/* After gathering the coordinates and converting them to screen space
we try to locate which of these have the highest/minimum x and y values.
The difference between highest/minimum x and y must correspond to
width and height.*/
if(_ObjectScreenCord.x > _Xmax.x){
_Xmax.x = _ObjectScreenCord.x;
}
else if(_ObjectScreenCord.x < _Xmin.x){
_Xmin.x = _ObjectScreenCord.x;
}
if(_ObjectScreenCord.y > _Ymax.x){
_Ymax.x = _ObjectScreenCord.y;
}
else if(_ObjectScreenCord.y < _Ymin.x){
_Ymin.x = _ObjectScreenCord.y;
}
}
//Too measure the distance between them, I use the Vector2 method Distance.
_Height = Vector2.Distance(_Ymax, _Ymin);
if (_Height > Screen.height || _Height < 0){
_Height = 0;
}
_Width = Vector2.Distance(_Xmax, _Xmin);
if (_Width > Screen.width || _Width < 0){
_Width = 0;
}
// Here we simply make a check on which of the height or the
// width is the biggest. It was a necessary part for my project.
if (_Height > _Width ){
return _Height;
} else {
return _Width;
}
/*
The method appears to work, though there are som serious issues when
Screen coordinates gets into negative values.
When screencoordinates get negative the width/height
explodes, and I think it is because of the
Trapez formed viewport. */
}
private Vector3 FindBoundCord (int i, GameObject _GameObject){
/*This is basically where the code starts. It starts out by creating a
* bounding box around the target GameObject.
It calculates the 8 coordinates forming the bounding box, and
returns them all to the for loop.
Because there are no real method which returns the coordinates
from the bounding box I had to create a switch/case which utillized
Bounds.center and Bounds.extents.*/
Bounds _TargetBounds = _GameObject.renderer.bounds;
Vector3 _TargetCenter = _TargetBounds.center;
Vector3 _TargetExtents = _TargetBounds.extents;
switch(i){
case 0:
return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y, _TargetExtents.z);
case 1:
return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y, _TargetExtents.z*-1);
case 2:
return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y*-1, _TargetExtents.z);
case 3:
return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y*-1, _TargetExtents.z*-1);
case 4:
return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y, _TargetExtents.z);
case 5:
return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y, _TargetExtents.z*-1);
case 6:
return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y*-1, _TargetExtents.z);
case 7:
return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y*-1, _TargetExtents.z*-1);
default:
return Vector3.zero;
}
}
Sorry for the horrible formatting, not used to post such long code snippits :)
You probably want to "dot" the (coordinate you find - the camera's position) with camera.main.transform.forward and check that it is on the same side of the camera.