BrawlLib.OpenGL.GLPanel Class Reference

Inheritance diagram for BrawlLib.OpenGL.GLPanel:

Public Member Functions
	GLPanel ()
void	ClearViewports ()
void	AddViewport (GLViewport v)
void	RemoveViewport (GLViewport v)
void	RemoveViewport (int index)
void	FitViewports ()
void	BeginUpdate ()
void	EndUpdate ()
new void	Capture ()
void	Release ()
GLViewport	GetViewport (int x, int y)
virtual void	CreateDefaultViewport ()
float	GetDepth (Vector2 v)
virtual float	GetDepth (int x, int y)
Vector3	TraceZ (Vector3 point, float z)
IEnumerator< GLViewport >	GetEnumerator ()

Protected Member Functions
override void	Dispose (bool disposing)
override void	OnLoad (EventArgs e)
virtual void	OnReset (object sender, EventArgs e)
virtual void	OnContextChanged (bool isNowCurrent)
override void	DestroyHandle ()
override void	OnHandleDestroyed (EventArgs e)
override void	OnPaintBackground (PaintEventArgs e)
override void	OnPaint (PaintEventArgs e)
override void	OnMouseMove (MouseEventArgs e)
override void	OnResize (EventArgs e)
virtual void	OnRender (PaintEventArgs e)
virtual void	OnRenderViewport (PaintEventArgs e, GLViewport v)

Protected Attributes
TKContext	_ctx
int	_updateCounter
GLViewport	_currentViewport
GLViewport	_highlightedViewport
List< GLViewport >	_viewports = new List<GLViewport>()

Properties
static GLPanel	Current [get]
TKContext	Context [get]
GLViewport	HighlightedViewport [get]
GLViewport	CurrentViewport [get, set]

Events
ViewportAction	OnCurrentViewportChanged

Constructor & Destructor Documentation

GLPanel()

BrawlLib.OpenGL.GLPanel.GLPanel ( )

inline

        {
            SetStyle(
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.Opaque |
                ControlStyles.ResizeRedraw,
                true);
 
            _viewports = new List<GLViewport>();
        }

Member Function Documentation

AddViewport()

void BrawlLib.OpenGL.GLPanel.AddViewport ( GLViewport  v )

inline

        {
            _viewports.Add(v);
            v._owner = this;
            v.Resize();
            v.OnInvalidate += Invalidate;
        }

BeginUpdate()

void BrawlLib.OpenGL.GLPanel.BeginUpdate ( )

inline

        {
            _updateCounter++;
        }

Capture()

new void BrawlLib.OpenGL.GLPanel.Capture ( )

inline

        {
            if (InvokeRequired)
            {
                Invoke(new Action(Capture));
                return;
            }
 
            if (_ctx == null)
            {
                _ctx = new TKContext(this);
            }
 
            _ctx.Capture();
        }

ClearViewports()

void BrawlLib.OpenGL.GLPanel.ClearViewports ( )

inline

        {
            foreach (GLViewport v in _viewports)
            {
                v._owner = null;
                v.OnInvalidate -= Invalidate;
            }
 
            _viewports.Clear();
        }

CreateDefaultViewport()

virtual void BrawlLib.OpenGL.GLPanel.CreateDefaultViewport ( )

inlinevirtual

Reimplemented in BrawlLib.Internal.Windows.Controls.Model_Panel.ModelPanel.

        {
            AddViewport(GLViewport.DefaultPerspective);
        }

DestroyHandle()

override void BrawlLib.OpenGL.GLPanel.DestroyHandle ( )

inlineprotected

        {
            DisposeContext();
            base.DestroyHandle();
        }

Dispose()

override void BrawlLib.OpenGL.GLPanel.Dispose ( bool  disposing )

inlineprotected

        {
            DisposeContext();
            base.Dispose(disposing);
        }

EndUpdate()

void BrawlLib.OpenGL.GLPanel.EndUpdate ( )

inline

        {
            if ((_updateCounter = Math.Max(_updateCounter - 1, 0)) == 0)
            {
                Invalidate();
            }
        }

FitViewports()

void BrawlLib.OpenGL.GLPanel.FitViewports ( )

inline

        {
            //TODO: this doesn't work right in every circumstance
 
            foreach (GLViewport v in _viewports)
            {
                Vector4 p = v.Percentages;
                GLViewport x = null, y = null, z = null, w = null;
                Vector4 diff = new Vector4(float.MaxValue);
                foreach (GLViewport v2 in _viewports)
                {
                    if (v2 == v)
                    {
                        continue;
                    }
 
                    float diff2 = Math.Abs(p._x - v2.Percentages._x);
                    if (diff2 <= diff._x)
                    {
                        x = v2;
                        diff._x = diff2;
                    }
 
                    diff2 = Math.Abs(p._y - v2.Percentages._y);
                    if (diff2 <= diff._y)
                    {
                        y = v2;
                        diff._y = diff2;
                    }
 
                    diff2 = Math.Abs(p._z - v2.Percentages._z);
                    if (diff2 <= diff._z)
                    {
                        z = v2;
                        diff._z = diff2;
                    }
 
                    diff2 = Math.Abs(p._w - v2.Percentages._w);
                    if (diff2 <= diff._w)
                    {
                        w = v2;
                        diff._w = diff2;
                    }
                }
 
                Vector4 average = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
                if (diff._x > 0.0f && x != null)
                {
                    average._x = (v.Percentages._x + x.Percentages._x) / 2.0f;
                    x.SetXPercentage(average._x);
                }
 
                if (diff._y > 0.0f && y != null)
                {
                    average._y = (v.Percentages._y + y.Percentages._y) / 2.0f;
                    y.SetYPercentage(average._y);
                }
 
                if (diff._z > 0.0f && z != null)
                {
                    average._z = (v.Percentages._z + z.Percentages._z) / 2.0f;
                    z.SetZPercentage(average._z);
                }
 
                if (diff._w > 0.0f && w != null)
                {
                    average._w = (v.Percentages._w + w.Percentages._w) / 2.0f;
                    w.SetWPercentage(average._w);
                }
 
                v.SetPercentages(average);
            }
        }

GetDepth() [1/2]

virtual float BrawlLib.OpenGL.GLPanel.GetDepth ( int  x, int  y  )

inlinevirtual

        {
            float val = 0;
            GL.ReadPixels(x, Height - y, 1, 1, PixelFormat.DepthComponent, PixelType.Float,
                ref val);
            return val;
        }

GetDepth() [2/2]

float BrawlLib.OpenGL.GLPanel.GetDepth ( Vector2  v )

inline

        {
            return GetDepth((int) (v._x + 0.5f), (int) (v._y + 0.5f));
        }

GetEnumerator()

IEnumerator< GLViewport > BrawlLib.OpenGL.GLPanel.GetEnumerator ( )

inline

        {
            return _viewports.GetEnumerator();
        }

GetViewport()

GLViewport BrawlLib.OpenGL.GLPanel.GetViewport ( int  x, int  y  )

inline

        {
            if (_viewports.Count == 1)
            {
                return _viewports[0];
            }
 
            x = x.Clamp(0, Width);
            y = Height - y.Clamp(0, Height);
 
            foreach (GLViewport w in _viewports)
            {
                if (x >= w.Region.X &&
                    x <= w.Region.X + w.Region.Width &&
                    y >= w.Region.Y &&
                    y <= w.Region.Y + w.Region.Height)
                {
                    return w;
                }
            }
 
            if (_viewports.Count == 0)
            {
                CreateDefaultViewport();
            }
 
            return _viewports[0];
        }

OnContextChanged()

virtual void BrawlLib.OpenGL.GLPanel.OnContextChanged ( bool  isNowCurrent )

inlineprotectedvirtual

Reimplemented in BrawlLib.Internal.Windows.Controls.Model_Panel.ModelPanel.

        {
            //Don't update anything if this context has just been released
            if (isNowCurrent)
            {
                OnResize(EventArgs.Empty);
            }
 
            _currentPanel = isNowCurrent ? this : null;
        }

OnHandleDestroyed()

override void BrawlLib.OpenGL.GLPanel.OnHandleDestroyed ( EventArgs  e )

inlineprotected

        {
            DisposeContext();
            base.OnHandleDestroyed(e);
        }

OnLoad()

override void BrawlLib.OpenGL.GLPanel.OnLoad ( EventArgs  e )

inlineprotected

        {
            _ctx = new TKContext(this);
 
            Capture();
 
            Vector3 v = (Vector3) BackColor;
            GL.ClearColor(v._x, v._y, v._z, 0.0f);
            GL.ClearDepth(1.0);
 
            OnInit(_ctx);
 
            _ctx.ContextChanged += OnContextChanged;
            _ctx.ResetOccured += OnReset;
 
            base.OnLoad(e);
        }

OnMouseMove()

override void BrawlLib.OpenGL.GLPanel.OnMouseMove ( MouseEventArgs  e )

inlineprotected

        {
            if (_viewports.Count > 1)
            {
                _highlightedViewport = GetViewport(e.X, e.Y);
            }
 
            base.OnMouseMove(e);
        }

OnPaint()

override void BrawlLib.OpenGL.GLPanel.OnPaint ( PaintEventArgs  e )

inlineprotected

        {
            if (_updateCounter > 0)
            {
                return;
            }
 
            if (_ctx == null)
            {
                base.OnPaint(e);
            }
            else if (Monitor.TryEnter(_ctx))
            {
                try
                {
                    //Direct OpenGL calls to this panel
                    Capture();
 
                    OnRender(e);
 
                    //Display newly rendered back buffer
                    _ctx.Swap();
 
                    //Check for errors
                    ErrorCode code = GL.GetError();
                    if (code != ErrorCode.NoError)
                    {
                        this.Reset(); //Stops the red X of death in its tracks
                    }
                }
                finally
                {
                    Monitor.Exit(_ctx);
                }
            }
        }

OnPaintBackground()

override void BrawlLib.OpenGL.GLPanel.OnPaintBackground ( PaintEventArgs  e )

inlineprotected

        {
        }

OnRender()

virtual void BrawlLib.OpenGL.GLPanel.OnRender ( PaintEventArgs  e )

inlineprotectedvirtual

Reimplemented in BrawlLib.Internal.Windows.Controls.GLTexturePanel.

        {
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            foreach (GLViewport v in _viewports)
            {
                OnRenderViewport(e, v);
            }
 
            Wii.Graphics.ShaderGenerator._forceRecompile = false;
        }

OnRenderViewport()

virtual void BrawlLib.OpenGL.GLPanel.OnRenderViewport ( PaintEventArgs  e, GLViewport  v  )

inlineprotectedvirtual

Reimplemented in BrawlLib.Internal.Windows.Controls.Model_Panel.ModelPanel.

        {
        }

OnReset()

virtual void BrawlLib.OpenGL.GLPanel.OnReset ( object  sender, EventArgs  e  )

inlineprotectedvirtual

        {
            OnInit(_ctx);
        }

OnResize()

override void BrawlLib.OpenGL.GLPanel.OnResize ( EventArgs  e )

inlineprotected

        {
            _ctx?.Update();
 
            foreach (GLViewport v in _viewports)
            {
                v.Resize();
            }
 
            Invalidate();
        }

Release()

void BrawlLib.OpenGL.GLPanel.Release ( )

inline

        {
            _ctx?.Release();
        }

RemoveViewport() [1/2]

void BrawlLib.OpenGL.GLPanel.RemoveViewport ( GLViewport  v )

inline

        {
            if (_viewports.Contains(v))
            {
                v._owner = null;
                v.OnInvalidate -= Invalidate;
                _viewports.Remove(v);
                FitViewports();
                Invalidate();
            }
        }

RemoveViewport() [2/2]

void BrawlLib.OpenGL.GLPanel.RemoveViewport ( int  index )

inline

        {
            if (index < 0 || index >= _viewports.Count)
            {
                return;
            }
 
            GLViewport v = _viewports[index];
            v._owner = null;
            v.OnInvalidate -= Invalidate;
            _viewports.RemoveAt(index);
        }

TraceZ()

Vector3 BrawlLib.OpenGL.GLPanel.TraceZ ( Vector3  point, float  z  )

inline

        {
            GLCamera camera = CurrentViewport.Camera;
            if (camera == null)
            {
                return new Vector3();
            }
 
            double a = point._z - z;
            //Perform trig functions, using camera for angles
 
            //Get angle, truncating to MOD 180
            //double angleX = _camera._rotation._y - ((int)(_camera._rotation._y / 180.0) * 180);
 
            double angleX = Math.IEEERemainder(-camera._rotation._y, 180.0);
            if (angleX < -90.0f)
            {
                angleX = -180.0f - angleX;
            }
 
            if (angleX > 90.0f)
            {
                angleX = 180.0f - angleX;
            }
 
            double angleY = Math.IEEERemainder(camera._rotation._x, 180.0);
            if (angleY < -90.0f)
            {
                angleY = -180.0f - angleY;
            }
 
            if (angleY > 90.0f)
            {
                angleY = 180.0f - angleY;
            }
 
            float lenX = (float) (Math.Tan(angleX * Math.PI / 180.0) * a);
            float lenY = (float) (Math.Tan(angleY * Math.PI / 180.0) * a);
 
            return new Vector3(point._x + lenX, point._y + lenY, z);
        }

Member Data Documentation

_ctx

TKContext BrawlLib.OpenGL.GLPanel._ctx

protected

_currentViewport

GLViewport BrawlLib.OpenGL.GLPanel._currentViewport

protected

_highlightedViewport

GLViewport BrawlLib.OpenGL.GLPanel._highlightedViewport

protected

_updateCounter

int BrawlLib.OpenGL.GLPanel._updateCounter

protected

_viewports

List<GLViewport> BrawlLib.OpenGL.GLPanel._viewports = new List<GLViewport>()

protected

Property Documentation

Context

TKContext BrawlLib.OpenGL.GLPanel.Context

get

Current

GLPanel BrawlLib.OpenGL.GLPanel.Current

staticget

        {
            get
            {
                if (_currentPanel == null && TKContext.CurrentContext != null)
                {
                    TKContext.CurrentContext.Capture(true);
                }
 
                return _currentPanel;
            }
        }

CurrentViewport

GLViewport BrawlLib.OpenGL.GLPanel.CurrentViewport

getset

        {
            get
            {
                if (_currentViewport == null)
                {
                    if (_viewports.Count == 0)
                    {
                        CreateDefaultViewport();
                    }
 
                    _currentViewport = _viewports[0];
                }
 
                if (_currentViewport._owner != this)
                {
                    _currentViewport._owner = this;
                }
 
                return _currentViewport;
            }
            set
            {
                _currentViewport = value;
 
                OnCurrentViewportChanged?.Invoke(_currentViewport);
 
                if (!_viewports.Contains(_currentViewport) && _currentViewport != null)
                {
                    AddViewport(_currentViewport);
                }
            }
        }

HighlightedViewport

GLViewport BrawlLib.OpenGL.GLPanel.HighlightedViewport

get

Event Documentation

OnCurrentViewportChanged

ViewportAction BrawlLib.OpenGL.GLPanel.OnCurrentViewportChanged

---

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

• BrawlLib/OpenGL/GLPanel.cs