untyped

global function CLUtilityMenu_Init

global function HudElement
global function GetContentScaleFactor
global function ClientCodeCallback_GetContentScaleFactor
global function ContentScaledX
global function ContentScaledY
global function Anim_EaseIn
global function Anim_EaseOut
global function ComputeSizeForAttachments
global function GetEntityScreenHeight

global function VisGroup_Init
global function VisGroup_AddElement
global function VisGroup_Show
global function VisGroup_Hide

table _visGroupStates = {}

global var HudElementGroup = null
global var CNotAVGUI = null

global struct VisGroup
{
	int visGroupID
	table< string, var > hudElements
}

void function VisGroup_Init( VisGroup visGroup )
{
	visGroup.visGroupID = CreateVisGroup()
}

void function VisGroup_AddElement( VisGroup visGroup, var elem )
{
	//Assert( hudElem instanceof HudElement )
	Assert( elem.GetVisGroupID() <= 0 )

	string name = Hud_GetHudName( elem )

	Assert( !(name in visGroup.hudElements), name + " already in menu!" )
	visGroup.hudElements[name] <- elem

	elem.SetVisGroupID( visGroup.visGroupID )
	elem.UpdateVisibility()
}

void function VisGroup_Show( VisGroup visGroup )
{
	VisGroup_SetVisible( visGroup.visGroupID, true )

	foreach ( hudElement in visGroup.hudElements )
		hudElement.UpdateVisibility()
}

void function VisGroup_Hide( VisGroup visGroup )
{
	VisGroup_SetVisible( visGroup.visGroupID, false )

	foreach ( hudElement in visGroup.hudElements )
		hudElement.UpdateVisibility()
}


function CLUtilityMenu_Init()
{
	level.hudElements <- {}

	// make the default visgroup
	VisGroup_Init( clGlobal.menuVisGroup )


	class HudElementGroup
	{
		groupName = null
		elements = null
		elementsArray = null
		isVisible = null
		ownerHud = null
		parentMenu = null	// the CMenu or CHudMenu that owns us; if this is non-null "Show()" and "Hide()" behave differently
		hideWithMenus = null

		constructor( groupName, ownerHud = null )
		{
			if ( ownerHud == null )
				ownerHud = Hud

			this.groupName = groupName
			this.ownerHud = ownerHud

			this.elements = {}
			this.elementsArray = []

			this.isVisible = false

			this.parentMenu = -1
		}

		function SetVisGroupID( visParentID )
		{
			this.parentMenu = visParentID
		}

		function HideWithMenus( state )
		{
			this.hideWithMenus = state

			if ( !this.hideWithMenus && this.groupName in level.menuHideGroups )
			{
				delete level.menuHideGroups[this.groupName]
				this.parentMenu = null
			}
			else if ( this.hideWithMenus && !(this.groupName in level.menuHideGroups) )
			{
				level.menuHideGroups[this.groupName] <- this
				this.parentMenu = GetLocalViewPlayer()
			}
		}

		function AddElement( hudElem )
		{
			//Assert( hudElem instanceof HudElement )
			//Assert( hudElem.ownerHud == this.ownerHud )

			local name = Hud_GetHudName( hudElem )

			Assert( !(name in this.elements) )
			this.elements[name] <- hudElem
			this.elementsArray.append( hudElem )

			if ( this.parentMenu != -1 )
			{
				hudElem.SetVisGroupID( this.parentMenu )
				hudElem.UpdateVisibility()
			}
		}

		function RemoveAllElements()
		{
			this.elements = {}
			this.elementsArray = []
		}

		function AddGroup( group )
		{
			Assert( group instanceof HudElementGroup )
			local elems = group.GetElements()
			foreach ( elem in elems )
			{
				//Assert( elem.ownerHud == this.ownerHud )
				this.AddElement( elem )
			}
		}

		function CreateElement( name, _ownerHud = null )
		{
			if ( _ownerHud == null )
				_ownerHud = this.ownerHud
			Assert( !(name in this.elements), "hud element already exists " + name )
			this.elements[name] <- HudElement( name, _ownerHud )
			this.elementsArray.append( this.elements[name] )

			if ( this.parentMenu != -1 )
			{
				this.elements[name].SetVisGroupID( this.parentMenu )
				this.elements[name].UpdateVisibility()
			}

			return this.elements[name]
		}

		function GetOrCreateElement( name, _ownerHud = null )
		{
			if ( _ownerHud == null )
				_ownerHud = this.ownerHud
			Assert( !(name in this.elements), "hud element already exists " + name )
			this.elements[name] <- _ownerHud.GetOrCreateHudElement( name )
			this.elementsArray.append( this.elements[name] )

			if ( this.parentMenu != -1 )
			{
				this.elements[name].SetVisGroupID( this.parentMenu )
				this.elements[name].UpdateVisibility()
			}

			return this.elements[name]
		}

		function SetClampToScreen( state )
		{
			foreach ( element in this.elements )
				element.SetClampToScreen( state )
		}

		function SetWorldSpaceScale( minScale, maxScale, minScaleDist, maxScaleDist )
		{
			foreach ( element in this.elements )
				element.SetWorldSpaceScale( minScale, maxScale, minScaleDist, maxScaleDist )
		}

		function SetADSFade( mindot, maxdot, minAlpha, maxAlpha )
		{
			foreach ( element in this.elements )
				element.SetADSFade( mindot, maxdot, minAlpha, maxAlpha )
		}

		function SetFOVFade( mindot, maxdot, minAlpha, maxAlpha )
		{
			foreach ( element in this.elements )
				element.SetFOVFade( mindot, maxdot, minAlpha, maxAlpha )
		}

		function SetDistanceFade( minDist, maxDist, minAlpha, maxAlpha )
		{
			foreach ( element in this.elements )
				element.SetDistanceFade( minDist, maxDist, minAlpha, maxAlpha )
		}

		function SetPulsate( minAlpha, maxAlpha, frequency )
		{
			foreach ( element in this.elements )
				element.SetPulsate( minAlpha, maxAlpha, frequency )
		}

		function ClearPulsate()
		{
			foreach ( element in this.elements )
				element.ClearPulsate()
		}


		function SetEntity( ent, offset = Vector( 0, 0, 0 ), screenXOffset = 0, screenYOffset = 0 )
		{
			foreach ( element in this.elements )
				element.SetEntity( ent, offset, screenXOffset, screenYOffset )
		}

		function SetEntityOverhead( ent, offset = Vector( 0, 0, 0 ), screenXOffset = 0, screenYOffset = 0 )
		{
			foreach ( element in this.elements )
				element.SetEntityOverhead( ent, offset, screenXOffset, screenYOffset )
		}

		function Show()
		{
			foreach ( element in this.elements )
				element.Show()
		}


		function Hide()
		{
			foreach ( element in this.elements )
			{
				element.Hide()
			}
		}

		function UpdateVisibility()
		{
			foreach ( element in this.elements )
				element.UpdateVisibility()
		}

		function IsVisible()
		{
			foreach ( element in this.elements )
				return element.IsVisible()
		}

		function GetBaseAlpha()
		{
			foreach ( element in this.elements )
				return element.GetBaseAlpha()
		}

		function GetBaseSize()
		{
			foreach ( element in this.elements )
				return element.GetBaseSize()
		}

		function GetBaseHeight()
		{
			foreach ( element in this.elements )
				return element.GetBaseHeight()
		}

		function GetBaseWidth()
		{
			foreach ( element in this.elements )
				return element.GetBaseWidth()
		}

		function GetBaseX()
		{
			foreach ( element in this.elements )
				return element.GetBaseX()
		}

		function GetBaseY()
		{
			foreach ( element in this.elements )
				return element.GetBaseY()
		}

		function GetX()
		{
			foreach ( element in this.elements )
				return element.GetX()
		}

		function GetY()
		{
			foreach ( element in this.elements )
				return element.GetY()
		}

		function GetAbsX()
		{
			foreach ( element in this.elements )
				return element.GetAbsX()
		}

		function GetAbsY()
		{
			foreach ( element in this.elements )
				return element.GetAbsY()
		}

		function SetColor( arg0 = null, arg1 = null, arg2 = null, arg3 = null )
		{
			if ( ( arg0 != null ) && ( arg1 == null ) && ( arg2 == null ) && ( arg3 == null ) )
			{
				foreach ( element in this.elements )
					element.SetColor( arg0 )
			}
			else if ( ( arg0 != null ) && ( arg1 != null ) && ( arg2 != null ) && ( arg3 != null ) )
			{
				local args = [arg0, arg1, arg2, arg3]

				foreach ( element in this.elements )
					element.SetColor( args )
			}
			else
			{
				Assert( 0, "Wrong number of arguments" )
			}
		}

		function SetText( text, arg0=null, arg1=null, arg2=null, arg3=null, arg4=null )
		{
			foreach ( element in this.elements )
				element.SetText( text, arg0, arg1, arg2, arg3, arg4 )
		}

		function SetTextTypeWriter( text, duration )
		{
			foreach ( element in this.elements )
				element.SetTextTypeWriter( text, duration )
		}

		function SetSize( width, height )
		{
			foreach ( element in this.elements )
				element.SetSize( width, height )
		}

		function SetSizeRelative( width, height )
		{
			foreach ( element in this.elements )
				element.SetSizeRelative( width, height )
		}

		function SetScale( wScale, hScale )
		{
			foreach ( element in this.elements )
				element.SetScale( wScale, hScale )
		}

		function GetTextWidth()
		{
			// just returns the width of the first element in the group
			foreach ( element in this.elements )
				return element.GetTextWidth()
		}

		function SetPosRelative( x, y )
		{
			foreach ( element in this.elements )
				element.SetPosRelative( x, y )
		}

		function SetPos( x, y )
		{
			foreach ( element in this.elements )
				element.SetPos( x, y )
		}

		function SetBasePos( x, y )
		{
			foreach ( element in this.elements )
				element.SetBasePos( x, y )
		}

		function SetX( x )
		{
			foreach ( element in this.elements )
				element.SetX( x )
		}

		function SetY( y )
		{
			foreach ( element in this.elements )
				element.SetY( y )
		}

		function SetBaseSize( width, height )
		{
			foreach ( element in this.elements )
				element.SetBaseSize( width, height )
		}

		function GetBasePos()
		{
			// just returns the position of the first element in the group
			foreach ( element in this.elementsArray )
				return element.GetBasePos()
		}

		function GetWidth()
		{
			// just returns the width of the first element in the group
			foreach ( element in this.elementsArray )
				return element.GetWidth()
		}

		function GetHeight()
		{
			// just returns the width of the first element in the group
			foreach ( element in this.elementsArray )
				return element.GetHeight()
		}

		function GetPos()
		{
			// just returns the position of the first element in the group
			foreach ( element in this.elementsArray )
				return element.GetPos()
		}

		function GetAbsPos()
		{
			foreach ( element in this.elements )
				return element.GetAbsPos()
		}

		function ReturnToBasePos()
		{
			foreach ( element in this.elements )
				element.ReturnToBasePos()
		}

		function ReturnToBaseSize()
		{
			foreach ( element in this.elements )
				element.ReturnToBaseSize()
		}

		function ReturnToBaseColor()
		{
			foreach ( element in this.elements )
				element.ReturnToBaseColor()
		}

		function SetAlpha( alpha )
		{
			foreach ( element in this.elements )
				element.SetAlpha( alpha )
		}

		function GetElement( name )
		{
			return this.elements[name]
		}

		function GetElements()
		{
			return this.elements
		}

		function GetElementsArray()
		{
			return this.elementsArray
		}

		function SetOrigin( origin )
		{
			foreach ( element in this.elements )
				element.SetOrigin( origin )
		}

		function MoveOverTime( x, y, duration, interpolator = 0 )
		{
			foreach ( element in this.elements )
				element.MoveOverTime( x, y, duration, interpolator )
		}

		function OffsetYOverTime( y, duration, interpolator = 0 )
		{
			foreach ( element in this.elements )
				element.MoveOverTime( element.GetBaseX(), element.GetBaseY() + y, duration, interpolator )
		}

		function FadeOverTime( alpha, duration, interpolator = 0 )
		{
			foreach ( element in this.elements )
				element.FadeOverTime( alpha, duration, interpolator )
		}

		function HideOverTime( duration, interpolator = 0 )
		{
			foreach ( element in this.elements )
				element.HideOverTime( duration, interpolator )
		}

		function FadeOverTimeDelayed( alpha, duration, delay )
		{
			foreach ( element in this.elements )
				element.FadeOverTimeDelayed( alpha, duration, delay )
		}

		function OffsetX( offset )
		{
			foreach ( element in this.elements )
				element.OffsetX( offset )
		}

		function OffsetY( offset )
		{
			foreach ( element in this.elements )
				element.OffsetY( offset )
		}

		function SetImage( material )
		{
			foreach ( element in this.elements )
				element.SetImage( material )
		}

		function SetBaseColor( r, g, b, a )
		{
			foreach ( element in this.elements )
				element.SetBaseColor( r, g, b, a )
		}

		function SetBaseAlpha( a )
		{
			foreach ( element in this.elements )
				element.SetBaseAlpha( a )
		}

		function SetPanelAlpha( a )
		{
			foreach ( element in this.elements )
				element.SetPanelAlpha( a )
		}

		function FadePanelOverTime( a, duration )
		{
			foreach ( element in this.elements )
				element.FadePanelOverTime( a, duration )
		}
	}

	class CNotAVGUI
	{
		s = null
		panel = null

		constructor( panelHandle = null )
		{
			this.s = {}
			this.panel = panelHandle
		}

		function GetPanel()
		{
			return this.panel
		}

		function EndSignal( signalName )
		{
			EndSignal( this, signalName )
		}
	}

}


function VisGroup_IsVisible( visGroupID )
{
	if ( visGroupID == 0 )
		return GetLocalViewPlayer().hudVisible

	return IsVisGroupVisible( visGroupID )
}

function VisGroup_SetVisible( visGroupID, state )
{
}

function HudElement( name, ownerHud = null )
{
	if ( ownerHud == null || ownerHud == Hud )
	{
		ownerHud = Hud

		if ( name in level.hudElements )
		{
			return level.hudElements[name]
		}

		level.hudElements[name] <- ownerHud.HudElement( name )
		return level.hudElements[name]
	}
	else
	{
		return ownerHud.HudElement( name )
	}
}



table< int, float > function GetContentScaleFactor( ownerHud = null )
{
	if ( ownerHud == null )
		ownerHud = Hud

	local screenSize = ownerHud.GetScreenSize()
	float screenSizeX = expect int( screenSize[0] ).tofloat()
	float screenSizeY = expect int( screenSize[1] ).tofloat()
	float aspectRatio = screenSizeX / screenSizeY
	table< int, float > scaleFactor
	scaleFactor[0] <- screenSizeX / ( 480.0 * aspectRatio )
	scaleFactor[1] <- screenSizeY / 480.0
	return scaleFactor
}

table< int, float > function ClientCodeCallback_GetContentScaleFactor()
{
	return GetContentScaleFactor()
}

function ContentScaledX( val )
{
	return (val * GetContentScaleFactor()[0])
}


function ContentScaledY( val )
{
	return (val * GetContentScaleFactor()[1])
}


enum Interpolators_e
{
	INTERPOLATOR_LINEAR,
	INTERPOLATOR_ACCEL,
	INTERPOLATOR_DEACCEL,
	INTERPOLATOR_PULSE,
	INTERPOLATOR_FLICKER,
	INTERPOLATOR_SIMPLESPLINE, // ease in / out
	INTERPOLATOR_BOUNCE,	   // gravitational bounce

	INTERPOLATOR_COUNT,
}

function GetInterpolationFunc( interpolator )
{
	switch ( interpolator )
	{
		case Interpolators_e.INTERPOLATOR_LINEAR:
			return Anim_Linear
		case Interpolators_e.INTERPOLATOR_ACCEL:
			return Anim_EaseIn
		case Interpolators_e.INTERPOLATOR_DEACCEL:
			return Anim_EaseOut
		case Interpolators_e.INTERPOLATOR_PULSE:
			return Anim_Linear
		case Interpolators_e.INTERPOLATOR_FLICKER:
			return Anim_Linear
		case Interpolators_e.INTERPOLATOR_SIMPLESPLINE:
			return Anim_SCurve
		case Interpolators_e.INTERPOLATOR_BOUNCE:
			return Anim_Linear
		default:
			break
	}
}


function Anim_Linear( x )
{
	return x
}

function Anim_EaseInSlow( x )
{
	x = x - 1
	return 1 - (pow( x, 2 ))
}

function Anim_EaseIn( x )
{
	x = x - 1
	return 1 - (pow( x, 6 ))
}

function Anim_EaseOut( x )
{
	return pow( x, 6 )
}

function Anim_SCurve( x )
{
	return x*x*(3 - 2*x)
}

function Anim_SCurve2( x )
{
	return x*x*x*(10 + x*(6*x - 15))
}

function Anim_Sin( x )
{
	return (1 - cos( PI*x )) / 2
}

/*
function HUD_VisibleForParent( parentObj )
{
	if ( type( parentObj ) == "int" )
		return _visParents[parentObj].IsVisible()
	else if ( parentObj instanceof CHudMenu )
		return parentObj.IsVisible()
	else if ( parentObj instanceof HudElementGroup )
		return parentObj.IsVisible()
	else if ( parentObj instanceof C_BaseEntity )
		return parentObj.IsHUDVisible()
	else
		Assert( 0, "Invalid parent specified for HudElement" )

	return null
}
*/

function ComputeSizeForAttachments( ent, bottomLeftID, topRightID, viewmodelNoFovAdjust )
{
	local blOrigin
	local trOrigin

	if ( viewmodelNoFovAdjust )
	{
		blOrigin = ent.GetAttachmentOrigin_ViewModelNoFOVAdjust( bottomLeftID )
		trOrigin = ent.GetAttachmentOrigin_ViewModelNoFOVAdjust( topRightID )
	}
	else
	{
		blOrigin = ent.GetAttachmentOrigin( bottomLeftID )
		trOrigin = ent.GetAttachmentOrigin( topRightID )
	}

	local blAngles = ent.GetAttachmentAngles( bottomLeftID )

	local thingToDot = trOrigin - blOrigin

	local height = -thingToDot.Dot( AnglesToRight( blAngles ) )
	local width = thingToDot.Dot( AnglesToForward( blAngles ) )

	return [ width, height ]
}


function GetEntityScreenHeight( entity ent, padding = 0 )
{
	entity player = GetLocalViewPlayer()
	EntityScreenSpaceBounds bounds = player.GetEntScreenSpaceBounds( ent, padding )
	return (bounds.y1 - bounds.y0)
}