BrawlLib.OpenGL.GLCamera Class Reference

Public Member Functions
void	SetProjectionParams (float aspect, float fovy, float farz, float nearz)
	GLCamera ()
	GLCamera (float width, float height, Vector3 defaultTranslate, Vector3 defaultRotate, Vector3 defaultScale)
Vector3	GetPoint ()
void	Scale (float x, float y, float z)
void	Scale (Vector3 v)
void	Zoom (float amt)
void	Translate (Vector3 v)
void	Translate (float x, float y, float z)
void	Rotate (float x, float y, float z)
void	Rotate (Vector3 v)
void	Rotate (float x, float y)
void	Pivot (float radius, float x, float y)
void	Set (Vector3 translate, Vector3 rotate, Vector3 scale)
void	Reset ()
void	CalculateProjection ()
void	SetDimensions (float width, float height)
Vector3	UnProject (Vector3 point)
	Projects a screen point to world coordinates. More...
Vector3	UnProject (float x, float y, float z)
	Projects a screen point to world coordinates. More...
Vector3	Project (float x, float y, float z)
	Projects a world point to screen coordinates. More...
Vector3	Project (Vector3 source)
	Projects a world point to screen coordinates. More...
Vector3	ProjectCameraSphere (Vector2 screenPoint, Vector3 center, float radius, bool clamp)
void	ProjectCameraPlanes (Vector2 screenPoint, Matrix transform, out Vector3 xy, out Vector3 yz, out Vector3 xz)
void	LoadProjection ()
void	LoadModelView ()
void	ZoomExtents (Vector3 point, float distance)
void	SaveDefaults ()

Public Attributes
Matrix	_matrix
Matrix	_matrixInverse
Matrix	_projectionMatrix
Matrix	_projectionInverse
Vector3	_rotation
Vector3	_scale
bool	_ortho
bool	_restrictXRot
bool	_restrictYRot
bool	_restrictZRot
float	_fovY = 45.0f
float	_nearZ = 1.0f
float	_farZ = 200000.0f
float	_width = 1
float	_height = 1
float	_aspect = 1
Vector4	_orthoDimensions = new Vector4(0, 1, 0, 1)
Vector3	_defaultTranslate
Vector3	_defaultRotate
Vector3	_defaultScale = new Vector3(1)
Action	OnPositionChanged

Properties
float	VerticalFieldOfView [get, set]
float	NearDepth [get, set]
float	FarDepth [get, set]
float	Width [get, set]
float	Height [get, set]
float	Aspect [get, set]
bool	Orthographic [get, set]

Events
Action	OnDimensionsChanged

Constructor & Destructor Documentation

GLCamera() [1/2]

BrawlLib.OpenGL.GLCamera.GLCamera ( )

inline

        {
            Reset();
        }

GLCamera() [2/2]

BrawlLib.OpenGL.GLCamera.GLCamera ( float  width, float  height, Vector3  defaultTranslate, Vector3  defaultRotate, Vector3  defaultScale  )

inline

        {
            _width = width;
            _height = height;
 
            _orthoDimensions = new Vector4(-_width / 2.0f, _width / 2.0f, _height / 2.0f, -_height / 2.0f);
 
            _scale = _defaultScale = defaultScale;
            _rotation = _defaultRotate = defaultRotate;
            _defaultTranslate = defaultTranslate;
 
            _matrix = Matrix.ReverseTransformMatrix(_scale, _rotation, _defaultTranslate);
            _matrixInverse = Matrix.TransformMatrix(_scale, _rotation, _defaultTranslate);
        }

Member Function Documentation

CalculateProjection()

void BrawlLib.OpenGL.GLCamera.CalculateProjection ( )

inline

        {
            if (_ortho)
            {
                _projectionMatrix = Matrix.OrthographicMatrix(_orthoDimensions, _nearZ, _farZ);
                _projectionInverse = Matrix.ReverseOrthographicMatrix(_orthoDimensions, _nearZ, _farZ);
            }
            else
            {
                _projectionMatrix = Matrix.PerspectiveMatrix(_fovY, _aspect, _nearZ, _farZ);
                _projectionInverse = Matrix.ReversePerspectiveMatrix(_fovY, _aspect, _nearZ, _farZ);
            }
        }

GetPoint()

Vector3 BrawlLib.OpenGL.GLCamera.GetPoint ( )

inline

        {
            return _matrixInverse.Multiply(new Vector3());
        }

LoadModelView()

void BrawlLib.OpenGL.GLCamera.LoadModelView ( )

inline

        {
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            fixed (Matrix* p = &_matrix)
            {
                GL.LoadMatrix((float*) p);
            }
        }

LoadProjection()

void BrawlLib.OpenGL.GLCamera.LoadProjection ( )

inline

        {
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            fixed (Matrix* p = &_projectionMatrix)
            {
                GL.LoadMatrix((float*) p);
            }
        }

Pivot()

void BrawlLib.OpenGL.GLCamera.Pivot ( float  radius, float  x, float  y  )

inline

        {
            _updating = true;
            Translate(0, 0, -radius);
            Rotate(x, y);
            Translate(0, 0, radius);
            _updating = false;
            PositionChanged();
        }

Project() [1/2]

Vector3 BrawlLib.OpenGL.GLCamera.Project ( float  x, float  y, float  z  )

inline

Projects a world point to screen coordinates.

Returns

2D coordinate on the screen with z as depth (z is not a distance value!)

        {
            return Project(new Vector3(x, y, z));
        }

Project() [2/2]

Vector3 BrawlLib.OpenGL.GLCamera.Project ( Vector3  source )

inline

Projects a world point to screen coordinates.

Returns

2D coordinate on the screen with z as depth (z is not a distance value!)

        {
            //This needs to be converted to a Vector4 in order to work
            //Also the order of the matrix multiplication matters
            Vector4 t1 = _matrix * (Vector4) source;
            Vector4 t2 = _projectionMatrix * t1;
            if (t2._w == 0)
            {
                return new Vector3();
            }
 
            Vector3 v = (Vector3) t2;
            return new Vector3(
                (v._x / 2.0f + 0.5f) * Width,
                Height - (v._y / 2.0f + 0.5f) * Height,
                (v._z + 1.0f) / 2.0f);
        }

ProjectCameraPlanes()

void BrawlLib.OpenGL.GLCamera.ProjectCameraPlanes ( Vector2  screenPoint, Matrix  transform, out Vector3  xy, out Vector3  yz, out Vector3  xz  )

inline

        {
            Vector3 ray1 = UnProject(screenPoint._x, screenPoint._y, 0.0f);
            Vector3 ray2 = UnProject(screenPoint._x, screenPoint._y, 1.0f);
 
            Vector3 center = transform.GetPoint();
 
            Maths.LinePlaneIntersect(ray1, ray2, center, (transform * Vector3.UnitX).Normalize(center), out yz);
            Maths.LinePlaneIntersect(ray1, ray2, center, (transform * Vector3.UnitY).Normalize(center), out xz);
            Maths.LinePlaneIntersect(ray1, ray2, center, (transform * Vector3.UnitZ).Normalize(center), out xy);
        }

ProjectCameraSphere()

Vector3 BrawlLib.OpenGL.GLCamera.ProjectCameraSphere ( Vector2  screenPoint, Vector3  center, float  radius, bool  clamp  )

inline

        {
            //Get ray points
            Vector3 ray1 = UnProject(screenPoint._x, screenPoint._y, 0.0f);
            Vector3 ray2 = UnProject(screenPoint._x, screenPoint._y, 1.0f);
 
            if (!Maths.LineSphereIntersect(ray1, ray2, center, radius, out Vector3 point))
            {
                //If no intersect is found, project the ray through the plane perpendicular to the camera.
                Maths.LinePlaneIntersect(ray1, ray2, center, GetPoint().Normalize(center), out point);
 
                //Clamp the point to edge of the sphere
                if (clamp)
                {
                    point = Maths.PointAtLineDistance(center, point, radius);
                }
            }
 
            return point;
        }

Reset()

void BrawlLib.OpenGL.GLCamera.Reset ( )

inline

        {
            _rotation = _defaultRotate;
            _scale = _defaultScale;
            _matrix = Matrix.ReverseTransformMatrix(_scale, _rotation, _defaultTranslate);
            _matrixInverse = Matrix.TransformMatrix(_scale, _rotation, _defaultTranslate);
 
            PositionChanged();
        }

Rotate() [1/3]

void BrawlLib.OpenGL.GLCamera.Rotate ( float  x, float  y  )

inline

        {
            Rotate(x, y, 0);
        }

Rotate() [2/3]

void BrawlLib.OpenGL.GLCamera.Rotate ( float  x, float  y, float  z  )

inline

        {
            Rotate(new Vector3(x, y, z));
        }

Rotate() [3/3]

void BrawlLib.OpenGL.GLCamera.Rotate ( Vector3  v )

inline

        {
            //Fix for left and right dragging when the camera is upside down
            if (_rotation._x < -90.0f || _rotation._x > 90.0f)
            {
                v._y = -v._y;
            }
 
            if (_restrictXRot)
            {
                v._x = 0.0f;
            }
 
            if (_restrictYRot)
            {
                v._y = 0.0f;
            }
 
            if (_restrictZRot)
            {
                v._z = 0.0f;
            }
 
            _rotation = (_rotation + v).RemappedToRange(-180.0f, 180.0f);
 
            Apply();
        }

SaveDefaults()

void BrawlLib.OpenGL.GLCamera.SaveDefaults ( )

inline

        {
            _defaultTranslate = GetPoint();
            _defaultRotate = _rotation;
            _defaultScale = _scale;
        }

Scale() [1/2]

void BrawlLib.OpenGL.GLCamera.Scale ( float  x, float  y, float  z  )

inline

        {
            Scale(new Vector3(x, y, z));
        }

Scale() [2/2]

void BrawlLib.OpenGL.GLCamera.Scale ( Vector3  v )

inline

        {
            _scale *= v;
            Apply();
        }

Set()

void BrawlLib.OpenGL.GLCamera.Set ( Vector3  translate, Vector3  rotate, Vector3  scale  )

inline

        {
            _scale = scale;
            _rotation = rotate;
 
            _matrix = Matrix.ReverseTransformMatrix(_scale, _rotation, translate);
            _matrixInverse = Matrix.TransformMatrix(_scale, _rotation, translate);
 
            PositionChanged();
        }

SetDimensions()

void BrawlLib.OpenGL.GLCamera.SetDimensions ( float  width, float  height  )

inline

        {
            _width = width;
            _height = height;
            _aspect = _width / _height;
 
            _orthoDimensions = new Vector4(-_width / 2.0f, _width / 2.0f, _height / 2.0f, -_height / 2.0f);
 
            CalculateProjection();
 
            OnDimensionsChanged?.Invoke();
        }

SetProjectionParams()

void BrawlLib.OpenGL.GLCamera.SetProjectionParams ( float  aspect, float  fovy, float  farz, float  nearz  )

inline

        {
            _aspect = aspect;
            _fovY = fovy;
            _farZ = farz;
            _nearZ = nearz;
 
            CalculateProjection();
        }

Translate() [1/2]

void BrawlLib.OpenGL.GLCamera.Translate ( float  x, float  y, float  z  )

inline

        {
            _matrix = Matrix.TranslationMatrix(-x, -y, -z) * _matrix;
            _matrixInverse.Translate(x, y, z);
 
            PositionChanged();
        }

Translate() [2/2]

void BrawlLib.OpenGL.GLCamera.Translate ( Vector3  v )

inline

        {
            Translate(v._x, v._y, v._z);
        }

UnProject() [1/2]

Vector3 BrawlLib.OpenGL.GLCamera.UnProject ( float  x, float  y, float  z  )

inline

Projects a screen point to world coordinates.

Returns

3D world point perpendicular to the camera with a depth value of z (z is not a distance value!)

        {
            //This needs to be a Vector4 converted to a Vector3 in order to work
            //Also the order of the matrix multiplication matters
            return (Vector3) (_matrixInverse * _projectionInverse * new Vector4(
                2.0f * (x / Width) - 1.0f,
                2.0f * ((Height - y) / Height) - 1.0f,
                2.0f * z - 1.0f,
                1.0f));
        }

UnProject() [2/2]

Vector3 BrawlLib.OpenGL.GLCamera.UnProject ( Vector3  point )

inline

Projects a screen point to world coordinates.

Returns

3D world point perpendicular to the camera with a depth value of z (z is not a distance value!)

        {
            return UnProject(point._x, point._y, point._z);
        }

Zoom()

void BrawlLib.OpenGL.GLCamera.Zoom ( float  amt )

inline

        {
            if (_ortho)
            {
                float scale = amt >= 0 ? amt / 2.0f : 2.0f / -amt;
                Scale(scale, scale, scale);
            }
            else
            {
                Translate(0.0f, 0.0f, amt);
            }
        }

ZoomExtents()

void BrawlLib.OpenGL.GLCamera.ZoomExtents ( Vector3  point, float  distance  )

inline

        {
            if (!_ortho)
            {
                _rotation = new Vector3();
            }
 
            Vector3 position = point + new Vector3(0.0f, 0.0f, distance);
            _matrix = Matrix.ReverseTransformMatrix(_scale, _rotation, position);
            _matrixInverse = Matrix.TransformMatrix(_scale, _rotation, position);
        }

Member Data Documentation

_aspect

float BrawlLib.OpenGL.GLCamera._aspect = 1

_defaultRotate

Vector3 BrawlLib.OpenGL.GLCamera._defaultRotate

_defaultScale

Vector3 BrawlLib.OpenGL.GLCamera._defaultScale = new Vector3(1)

_defaultTranslate

Vector3 BrawlLib.OpenGL.GLCamera._defaultTranslate

_farZ

float BrawlLib.OpenGL.GLCamera._farZ = 200000.0f

_fovY

float BrawlLib.OpenGL.GLCamera._fovY = 45.0f

_height

float BrawlLib.OpenGL.GLCamera._height = 1

_matrix

Matrix BrawlLib.OpenGL.GLCamera._matrix

_matrixInverse

Matrix BrawlLib.OpenGL.GLCamera._matrixInverse

_nearZ

float BrawlLib.OpenGL.GLCamera._nearZ = 1.0f

_ortho

bool BrawlLib.OpenGL.GLCamera._ortho

_orthoDimensions

Vector4 BrawlLib.OpenGL.GLCamera._orthoDimensions = new Vector4(0, 1, 0, 1)

_projectionInverse

Matrix BrawlLib.OpenGL.GLCamera._projectionInverse

_projectionMatrix

Matrix BrawlLib.OpenGL.GLCamera._projectionMatrix

_restrictXRot

bool BrawlLib.OpenGL.GLCamera._restrictXRot

_restrictYRot

bool BrawlLib.OpenGL.GLCamera._restrictYRot

_restrictZRot

bool BrawlLib.OpenGL.GLCamera._restrictZRot

_rotation

Vector3 BrawlLib.OpenGL.GLCamera._rotation

_scale

Vector3 BrawlLib.OpenGL.GLCamera._scale

_width

float BrawlLib.OpenGL.GLCamera._width = 1

OnPositionChanged

Action BrawlLib.OpenGL.GLCamera.OnPositionChanged

Property Documentation

Aspect

float BrawlLib.OpenGL.GLCamera.Aspect

getset

        {
            get => _aspect;
            set
            {
                _aspect = value;
                CalculateProjection();
            }
        }

FarDepth

float BrawlLib.OpenGL.GLCamera.FarDepth

getset

        {
            get => _farZ;
            set
            {
                _farZ = value;
                CalculateProjection();
            }
        }

Height

float BrawlLib.OpenGL.GLCamera.Height

getset

        {
            get => _height;
            set
            {
                _height = value;
                CalculateProjection();
            }
        }

NearDepth

float BrawlLib.OpenGL.GLCamera.NearDepth

getset

        {
            get => _nearZ;
            set
            {
                _nearZ = value;
                CalculateProjection();
            }
        }

Orthographic

bool BrawlLib.OpenGL.GLCamera.Orthographic

getset

        {
            get => _ortho;
            set
            {
                if (_ortho == value)
                {
                    return;
                }
 
                _ortho = value;
                CalculateProjection();
            }
        }

VerticalFieldOfView

float BrawlLib.OpenGL.GLCamera.VerticalFieldOfView

getset

        {
            get => _fovY;
            set
            {
                _fovY = value;
                CalculateProjection();
            }
        }

Width

float BrawlLib.OpenGL.GLCamera.Width

getset

        {
            get => _width;
            set
            {
                _width = value;
                CalculateProjection();
            }
        }

Event Documentation

OnDimensionsChanged

Action BrawlLib.OpenGL.GLCamera.OnDimensionsChanged

---

The documentation for this class was generated from the following file:

• BrawlLib/OpenGL/GLCamera.cs