SCR_PIPSightsComponent.c

Go to the documentation of this file.

[EntityEditorProps(category: "GameScripted/Weapon/Sights/Picture in Picture Sights", description: "", color: "0 0 255 255")]
class SCR_PIPSightsComponentClass: ScriptedSightsComponentClass
{
    [Attribute("{EF091399D840192D}UI/layouts/Sights/PictureInPictureSightsLayout.layout", UIWidgets.ResourceNamePicker, "The layout used for this PIP component", params: "layout")]
    protected ResourceName m_sLayoutResource;
 
    [Attribute("RTTexture0", UIWidgets.EditBox, "Name of RTTexture widget within provided layout")]
    protected string m_sRTTextureWidgetName;
 
    [Attribute("RenderTarget0", UIWidgets.EditBox, "Name of RenderTarget widget within provided layout")]
    protected string m_sRTargetWidgetName;
 
    [Attribute("1", UIWidgets.Slider, "Camera index used for this PIP component", params: "0 31 1")]
    protected int m_iCameraIndex;
 
    [Attribute("12.5", UIWidgets.Slider, "Camera field of view used by this PIP component", params: "0 89.9 0.1")]
    protected float m_fCameraFOV;
 
    [Attribute("0.2", UIWidgets.Slider, "Camera near clipping plane", params: "0 1000 0.01")]
    protected float m_fNearPlane;
 
    [Attribute("1500", UIWidgets.Slider, "Camera field of view used by this PIP component", params: "0 5000 1")]
    protected float m_fFarPlane;
 
    // Point info?
    [Attribute("1.0", UIWidgets.EditBox, "Scale of resolution used by the PIP", params: "0.1 1 0.1")]
    protected float m_fResolutionScale;
 
    // Point info?
    [Attribute("0 0 0", UIWidgets.EditBox, "Camera offset used for this PIP")]
    protected vector m_vCameraPoint;
 
    //------------------------------------------------------------------------------------------------
    ResourceName GetLayoutResource()
    {
        return m_sLayoutResource;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetRTTextureWidgetName()
    {
        return m_sRTTextureWidgetName;
    }
 
    //------------------------------------------------------------------------------------------------
    string GetRTargetWidgetName()
    {
        return m_sRTargetWidgetName;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetCameraIndex()
    {
        return m_iCameraIndex;
    }
    
    //------------------------------------------------------------------------------------------------
    float GetCameraFOV()
    {
        return m_fCameraFOV;
    }
    
    //------------------------------------------------------------------------------------------------
    float GetNearPlane()
    {
        return m_fNearPlane;
    }
    
    //------------------------------------------------------------------------------------------------
    float GetFarPlane()
    {
        return m_fFarPlane;
    }
    
    //------------------------------------------------------------------------------------------------
    float GetResolutionScale()
    {
        return m_fResolutionScale;
    }
    
    //------------------------------------------------------------------------------------------------
    vector GetCameraPoint()
    {
        return m_vCameraPoint;
    }
};
 
//------------------------------------------------------------------------------------------------
class SCR_PIPSightsComponent : ScriptedSightsComponent
{
    protected ref Widget m_wRoot;

    protected IEntity m_pOwner;

    protected RTTextureWidget m_wRenderTargetTextureWidget;

    protected RenderTargetWidget m_wRenderTargetWidget;

    protected ScriptCamera m_PIPCamera;
    
    protected bool m_bIsEnabled;
    
    // Prefab data getters
    
    protected ResourceName GetLayoutResource()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetLayoutResource();
    }
    
    protected string GetRTTextureWidgetName()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetRTTextureWidgetName();
    }
 
    protected string GetRTargetWidgetName()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetRTargetWidgetName();
    }
    
    protected int GetCameraIndex()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetCameraIndex();
    }
    
    protected float GetCameraFOV()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetCameraFOV();
    }
    
    protected float GetNearPlane()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetNearPlane();
    }
    
    protected float GetFarPlane()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetFarPlane();
    }
    
    protected float GetResolutionScale()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetResolutionScale();
    }
    
    protected vector GetCameraPoint()
    {
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
        return data.GetCameraPoint();
    }
 
    #ifdef WORKBENCH
    //------------------------------------------------------------------------------------------------
    override int _WB_GetAfterWorldUpdateSpecs(IEntity owner, IEntitySource src)
    {
        return EEntityFrameUpdateSpecs.CALL_WHEN_ENTITY_VISIBLE;
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void _WB_AfterWorldUpdate(IEntity owner, float timeSlice)
    {
        const float axisLength = 0.1;
 
        vector origin = owner.GetOrigin() + GetCameraPoint();
        vector right = origin + owner.GetTransformAxis(0) * axisLength;
        vector up = origin + owner.GetTransformAxis(1) * axisLength;
        vector fwd = origin + owner.GetTransformAxis(2) * axisLength;
 
        ref auto rightArrow = Shape.CreateArrow(origin, right, 0.01, ARGB(240,255,0,0), ShapeFlags.ONCE);
        ref auto upArrow = Shape.CreateArrow(origin, up, 0.01, ARGB(240,0,255,0), ShapeFlags.ONCE);
        ref auto fwdArrow = Shape.CreateArrow(origin, fwd, 0.01, ARGB(240,0,0,255), ShapeFlags.ONCE);
    }
    #endif
 
    //------------------------------------------------------------------------------------------------
    void SetEnabled(bool enabled)
    {
        // A component without an owner shouldnt exist
        if (!m_pOwner)
            return;
 
        // disabled->enabled
        // Create neccessary items
        if (enabled && !m_bIsEnabled)
        {
            SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
            
            // Try to create UI for PIP,
            // output params are either set to valid ones,
            // or root itself is set to null and destroyed
            if (!m_wRoot || !m_wRenderTargetTextureWidget || !m_wRenderTargetWidget)
                m_wRoot = CreateUI(data.GetLayoutResource(), data.GetRTTextureWidgetName(), data.GetRTargetWidgetName(), m_wRenderTargetTextureWidget, m_wRenderTargetWidget);
 
            if (!m_wRoot)
            {
                Print("Could not create PIP layout!");
                return;
            }
 
            // Create PIP camera
            if (!m_PIPCamera)
                m_PIPCamera = CreateCamera(m_pOwner, data.GetCameraPoint(), data.GetCameraIndex(), data.GetCameraFOV(), data.GetNearPlane(), data.GetFarPlane());
 
            // Set camera index of render target widget
            BaseWorld baseWorld = m_pOwner.GetWorld();
            m_wRenderTargetWidget.SetWorld(baseWorld, data.GetCameraIndex());
 
            // Set resolution scale
            m_wRenderTargetWidget.SetResolutionScale(data.GetResolutionScale(), data.GetResolutionScale());
 
            // Set RTT on parent
            m_wRenderTargetTextureWidget.SetRenderTarget(m_pOwner);
 
            m_bIsEnabled = true;
            return;
        }
 
        // enabled -> disabled
        if (!enabled && m_bIsEnabled)
        {
            Destroy();
 
            m_bIsEnabled = false;
            return;
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected Widget CreateUI(string layout, string rtTextureName, string rtName, out RTTextureWidget RTTexture, out RenderTargetWidget RTWidget)
    {
        // Empty layout, cannot create any widget
        if (layout == string.Empty)
            return null;
 
        // Create layout
        Widget root = GetGame().GetWorkspace().CreateWidgets(layout);
 
        // Layout was not created successfully
        if (!root)
            return null;
 
        // We dont have required RT widgets, delete layout and terminate
        RTTexture = RTTextureWidget.Cast(root.FindAnyWidget(rtTextureName));
        RTWidget = RenderTargetWidget.Cast(root.FindAnyWidget(rtName));
        if (!RTTexture || !RTWidget)
        {
            root.RemoveFromHierarchy();
            return null;
        }
 
        return root;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DestroyUI(Widget root)
    {
        if (root)
        {
            root.RemoveFromHierarchy();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected ScriptCamera CreateCamera(IEntity parent, vector position, int cameraIndex, float fov, float nearPlane, float farPlane)
    {
        // Spawn camera
        BaseWorld baseWorld = parent.GetWorld();
        ScriptCamera pipCamera = ScriptCamera.Cast(GetGame().SpawnEntity(ScriptCamera, baseWorld));
        SCR_PIPSightsComponentClass data = SCR_PIPSightsComponentClass.Cast(GetComponentData(GetOwner()));
 
        // Since we use autotransform,
        // we set camera matrix to "local" coordinates
        vector mat[4];
        Math3D.MatrixIdentity3(mat);
        mat[3] = position;
 
 
        pipCamera.SetTransform(mat);
        pipCamera.Index = cameraIndex;
        pipCamera.FreeFly = false;
 
        // These are attributes used in constructor of
        // scriptCamera so they will most likely not work
 
        /*
        pipCamera.FOV = data.GetCameraFOV();
        pipCamera.NearPlane = nearPlane;
        pipCamera.FarPlane = farPlane;
        */
 
        // Instead we do it the old fashionate way
        baseWorld.SetCameraVerticalFOV(cameraIndex, data.GetCameraFOV());
        baseWorld.SetCameraFarPlane(cameraIndex, farPlane);
        baseWorld.SetCameraNearPlane(cameraIndex, nearPlane);
 
        // Set camera to hierarchy
        parent.AddChild(pipCamera, -1, EAddChildFlags.AUTO_TRANSFORM);
        return pipCamera;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DestroyCamera(ScriptCamera camera)
    {
        if (camera)
        {
            IEntity cameraParent = camera.GetParent();
            if (cameraParent)
                cameraParent.RemoveChild(camera);
 
            delete camera;
        }
    }
 
    //------------------------------------------------------------------------------------------------
    // Destroy everything this component created during its lifetime
    protected void Destroy()
    {
        m_wRenderTargetTextureWidget.RemoveRenderTarget(m_pOwner);
        DestroyCamera(m_PIPCamera);
        DestroyUI(m_wRoot);
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnSightADSActivated()
    {
        SetEnabled(true);
        super.OnSightADSActivated();
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnSightADSDeactivated()
    {
        SetEnabled(false);
        super.OnSightADSDeactivated();
    }
 
    //------------------------------------------------------------------------------------------------
    protected override void OnInit(IEntity owner)
    {
        m_pOwner = owner;
    }
 
    //------------------------------------------------------------------------------------------------
    void SCR_PIPSightsComponent(IEntityComponentSource src, IEntity ent, IEntity parent)
    {
    }
 
    //------------------------------------------------------------------------------------------------
    void ~SCR_PIPSightsComponent()
    {
        Destroy();
    }
};