C_BaseViewModel.cs

using UnityEngine; // For Vector3
using System.Collections.Generic;
using System;
using uSource.Formats.Source.MDL;
using NUnit.Framework.Constraints;
using System.Runtime.InteropServices.WindowsRuntime;



public class C_BaseViewModel : MonoBehaviour
{
    private bool m_bReadyToDraw;
    private int m_nOldAnimationParity;
    private int m_nAnimationParity;
    private float m_flAnimTime;

    public object MATERIAL_CULLMODE_CCW { get; private set; }
    public object MATERIAL_CULLMODE_CW { get; private set; }
    public int STUDIO_RENDER { get; private set; }
    public object LATCH_ANIMATION_VAR { get; private set; }
    public object OBS_MODE_IN_EYE { get; private set; }
    public int TICK_INTERVAL { get; private set; }
    public int AE_CL_PLAYSOUND { get; private set; }
    public int CL_EVENT_SOUND { get; private set; }

    public void FormatViewModelAttachment(int nAttachment, Matrix4x4 attachmentToWorld)
    {
        Vector3 vecOrigin;
        MatrixPosition(attachmentToWorld, out vecOrigin);
        FormatViewModelAttachment(vecOrigin, false);
        PositionMatrix(vecOrigin, ref attachmentToWorld);
    }

    private void MatrixPosition(Matrix4x4 attachmentToWorld, out Vector3 vecOrigin)
    {
        vecOrigin = new();
        return;
    }

    private void PositionMatrix(Vector3 vecOrigin, ref Matrix4x4 attachmentToWorld)
    {
        return;
    }

    private void FormatViewModelAttachment(Vector3 vecOrigin, bool v)
    {
        return;
    }

    public bool IsViewModel()
    {
        return true;
    }

    public void UncorrectViewModelAttachment(ref Vector3 vOrigin)
    {
        FormatViewModelAttachment(vOrigin, true);
    }

    public void FireEvent(Vector3 origin, Vector3 angles, int eventId, string options)
    {
        if (eventId == AE_CL_PLAYSOUND || eventId == CL_EVENT_SOUND)
        {
            GetOwner getOwner = new();
            if (getOwner != null)
            {
                CLocalPlayerFilter filter = new CLocalPlayerFilter();
                EmitSound(filter, GetOwner.GetSoundSourceIndex(), options, GetAbsOrigin());
                return;
            }
        }

        C_BaseCombatWeapon pWeapon = GetActiveWeapon();
        if (pWeapon != null)
        {haptics haptics = new haptics();
            if (haptics != null)
                haptics.ProcessHapticEvent(4, "Weapons", pWeapon.GetName(), string.Format("{0}", eventId));

            bool bResult = pWeapon.OnFireEvent(this, origin, angles, eventId, options);
            if (!bResult)
            {
                BaseClass.FireEvent(origin, angles, eventId, options);
            }
        }
    }

    private object GetAbsOrigin()
    {
        return GetAbsOrigin();
    }

    private void EmitSound(CLocalPlayerFilter filter, object value1, string options, object value2)
    {
        return;
    }

    public bool Interpolate(float currentTime)
    {
        CStudioHdr pStudioHdr = GetModelPtr();
        UpdateAnimationParity();
        bool bret = BaseClass.Interpolate(currentTime);
        float elapsed_time = currentTime - m_flAnimTime;
        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();

        if (GetPredictable() || IsClientCreated())
        {
            if (pPlayer != null)
            {
                float curtime = pPlayer.GetFinalPredictedTime();
                elapsed_time = curtime - m_flAnimTime;

                if (!engine.IsPaused())
                {
                    elapsed_time += (gpGlobals.interpolation_amount * TICK_INTERVAL);
                }
            }
        }

        if (elapsed_time < 0)
        {
            elapsed_time = 0;
        }

        float dt = elapsed_time * GetSequenceCycleRate(pStudioHdr, GetSequence()) * GetPlaybackRate();
        if (dt >= 1.0f)
        {
            if (!IsSequenceLooping(GetSequence()))
            {
                dt = 0.999f;
            }
            else
            {
                dt = dt % 1.0f;
            }
        }

        SetCycle(dt);
        return bret;
    }

    private CStudioHdr GetModelPtr()
    {
        throw new NotImplementedException();
    }

    private bool IsClientCreated()
    {
        throw new NotImplementedException();
    }

    private bool IsSequenceLooping(object v)
    {
        return new();
    }

    private float GetSequenceCycleRate(CStudioHdr pStudioHdr, object v)
    {
        return new();
    }

    private object GetSequence()
    {
        return new();
    }

    private int GetPlaybackRate()
    {return new();
    }

    private bool ShouldFlipViewModel()
    {
        CBaseCombatWeapon pWeapon = m_hWeapon.Get();
        if (pWeapon != null)
        {
             FileWeaponInfo_t pInfo = pWeapon.GetWpnData();
            return pInfo.m_bAllowFlipping && pInfo.m_bBuiltRightHanded != cl_righthand.GetBool();
        }
        return false;
    }

    public void ApplyBoneMatrixTransform(ref Matrix4x4 transform)
    {
        if (ShouldFlipViewModel())
        {
            Matrix4x4 viewMatrix, viewMatrixInverse;
            CViewSetup pSetup = view.GetPlayerViewSetup();
            AngleMatrix(pSetup.angles, pSetup.origin, out viewMatrixInverse);
            MatrixInvert(viewMatrixInverse, out viewMatrix);

            Matrix4x4 temp;
            ConcatTransforms(viewMatrix, transform, out temp);

            temp.m00 = -temp.m00;
            temp.m01 = -temp.m01;
            temp.m02 = -temp.m02;
            temp.m03 = -temp.m03;

            ConcatTransforms(viewMatrixInverse, temp, ref transform , out transform);
        }
    }

    private void ConcatTransforms(Matrix4x4 viewMatrixInverse, Matrix4x4 temp, ref Matrix4x4 transform1, out Matrix4x4 transform2)
    {
        transform2 = new();
        return;
    }

    private void AngleMatrix(object angles, object origin, out Matrix4x4 viewMatrixInverse)
    {
        viewMatrixInverse = new();

    }

    private void MatrixInvert(Matrix4x4 viewMatrixInverse, out Matrix4x4 viewMatrix)
    {
        viewMatrix = new();
    }

    private void ConcatTransforms(Matrix4x4 viewMatrix, Matrix4x4 transform, out Matrix4x4 temp)
    {
        temp = new();
        
    }

    public bool ShouldDraw()
    {
        if (engine.IsHLTV())
        {
            GetOwner getOwner = new();
            return HLTVCamera.GetMode() == OBS_MODE_IN_EYE && HLTVCamera.GetPrimaryTarget() == getOwner;
        }
        else
        {
            return BaseClass.ShouldDraw();
        }
    }

    private class HLTVCamera
    {

       public static object GetMode()
        {
            return new();
        }

        internal static GetOwner GetPrimaryTarget()
        {
            return new();
        }
    }

    public int DrawModel(int flags)
    {
        if (!m_bReadyToDraw)
            return 0;

        if ((flags & STUDIO_RENDER) != 0)
        {
            float blend = (float)(GetFxBlend() / 255.0f);
            if (blend <= 0.0f)
                return 0;

            render.SetBlend(blend);
            float[] color = new float[3];
            GetColorModulation(color);
            render.SetColorModulation(color);
        }

        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();
        C_BaseCombatWeapon pWeapon = GetOwningWeapon();
        int ret;

        if (pPlayer != null && pPlayer.IsOverridingViewmodel())
        {
            ret = pPlayer.DrawOverriddenViewmodel(this, flags);
        }
        else if (pWeapon != null && pWeapon.IsOverridingViewmodel())
        {
            ret = pWeapon.DrawOverriddenViewmodel(this, flags);
        }
        else
        {
            ret = BaseClass.DrawModel(flags);
        }

        if ((flags & STUDIO_RENDER) != 0)
        {
            if (m_nOldAnimationParity != m_nAnimationParity)
            {
                m_nOldAnimationParity = m_nAnimationParity;
            }

            if (pWeapon != null)
            {
                pWeapon.ViewModelDrawn(this);
            }
        }

        return ret;
    }

    private void GetColorModulation(float[] color)
    {
        return;
    }

    public int InternalDrawModel(int flags)
    {
        CMatRenderContextPtr materials = new();
        CMatRenderContextPtr pRenderContext = materials;
        if (ShouldFlipViewModel())
            pRenderContext.CullMode(MATERIAL_CULLMODE_CW);

        int ret = BaseClass.InternalDrawModel(flags);
        pRenderContext.CullMode(MATERIAL_CULLMODE_CCW);
        return ret;
    }

    public int DrawOverriddenViewmodel(int flags)
    {
        return BaseClass.DrawModel(flags);
    }

    public int GetFxBlend()
    {
        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();
        if (pPlayer != null && pPlayer.IsOverridingViewmodel())
        {
            pPlayer.ComputeFxBlend();
            return pPlayer.GetFxBlend();
        }

        C_BaseCombatWeapon pWeapon = GetOwningWeapon();
        if (pWeapon != null && pWeapon.IsOverridingViewmodel())
        {
            pWeapon.ComputeFxBlend();
            return pWeapon.GetFxBlend();
        }

        return BaseClass.GetFxBlend();
    }

    public bool IsTransparent()
    {
        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();
        if (pPlayer != null && pPlayer.IsOverridingViewmodel())
        {
            return pPlayer.ViewModel_IsTransparent();
        }

        C_BaseCombatWeapon pWeapon = GetOwningWeapon();
        if (pWeapon != null && pWeapon.IsOverridingViewmodel())
            return pWeapon.ViewModel_IsTransparent();

        return BaseClass.IsTransparent();
    }

    public bool UsesPowerOfTwoFrameBufferTexture()
    {
        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();
        if (pPlayer != null && pPlayer.IsOverridingViewmodel())
        {
            return pPlayer.ViewModel_IsUsingFBTexture();
        }

        C_BaseCombatWeapon pWeapon = GetOwningWeapon();
        if (pWeapon != null && pWeapon.IsOverridingViewmodel())
        {
            return pWeapon.ViewModel_IsUsingFBTexture();
        }

        return BaseClass.UsesPowerOfTwoFrameBufferTexture();
    }

    private C_BaseCombatWeapon GetOwningWeapon()
    {char[] name = new char[1];
        C_BaseCombatWeapon C_BaseCombatWeapon = new C_BaseCombatWeapon();
        return new()
        {

          
        }
        ;


    }

    public void UpdateAnimationParity()
    {
        C_BasePlayer pPlayer = C_BasePlayer.GetLocalPlayer();
        if (m_nOldAnimationParity != m_nAnimationParity && !GetPredictable())
        {
            float curtime = (pPlayer != null && IsIntermediateDataAllocated()) ? pPlayer.GetFinalPredictedTime() : gpGlobals.curtime;
            SetCycle(0.0f);
            m_flAnimTime = curtime;
        }
    }

    private bool GetPredictable()
    {
        return new();
    }

    private void SetCycle(float v)
    {
       return ;
    }

    private bool IsIntermediateDataAllocated()
    {
        return new()
        {



        };
        
    }

    public void OnDataChanged(DataUpdateType updateType)
    {
        SetPredictionEligible(true);
        BaseClass.OnDataChanged(updateType);
    }

    private void SetPredictionEligible(bool v)
    {
        return;
    }

    public void PostDataUpdate(DataUpdateType updateType)
    {
        BaseClass.PostDataUpdate(updateType);
        OnLatchInterpolatedVariables(LATCH_ANIMATION_VAR);
    }

    private void OnLatchInterpolatedVariables(object lATCH_ANIMATION_VAR)
    {



        return;
    }

    public void AddEntity()
    {
        if (IsNoInterpolationFrame())
        {
            ResetLatched();
        }
    }

    private bool IsNoInterpolationFrame()
    {
        return IsNoInterpolationFrame();
    }

    private void ResetLatched()
    {
        return;
    }

    public void GetBoneControllers(float[] controllers)
    {
        BaseClass.GetBoneControllers(controllers);
        C_BaseCombatWeapon pWeapon = GetActiveWeapon();
        if (pWeapon != null)
        {
            pWeapon.GetViewmodelBoneControllers(this, controllers);
        }
    }

    private C_BaseCombatWeapon GetActiveWeapon()
    {
        return GetActiveWeapon();
            {



        };
    }

    public RenderGroup_t GetRenderGroup()
    {
        return RenderGroup_t.RENDER_GROUP_VIEW_MODEL_OPAQUE;
    }

    // Additional methods and properties would be defined here...
}

internal class CLocalPlayerFilter
{
}

internal class GetOwner
{
    internal static object GetSoundSourceIndex()
    {
        return new();
       
    }
}

internal class render
{
    internal static void SetBlend(float blend)
    {
        return;
    }

    internal static void SetColorModulation(float[] color)
    {
        return;
    }
}

internal class m_hWeapon
{
    internal static CBaseCombatWeapon Get()
    {
        return new()
        {

         
        };
       
    }
}

internal class CBaseCombatWeapon
{
    internal FileWeaponInfo_t GetWpnData()
    {
        return new()
        {
            m_bAllowFlipping = true,
        };


     
    }
}

public class DataUpdateType
{
}

internal class haptics
{
    internal static void ProcessHapticEvent(int v1, string v2, object value, string v3)
    {
        return;
    }
}

internal class CMatRenderContextPtr
{
    internal void CullMode(object mATERIAL_CULLMODE_CW)
    {
        return;
    }
}

internal class view
{
    internal static CViewSetup GetPlayerViewSetup()
    {
        return new()
        {
            angles = new object(),

        };
    }
}

internal class CViewSetup
{
    public object angles { get; internal set; }
    public object origin { get; internal set; }
}

internal class cl_righthand
{
    internal static object GetBool()
    {
        return new()
        {
       
       
        };
    }
}

internal class FileWeaponInfo_t
{
    internal object m_bBuiltRightHanded;

    public bool m_bAllowFlipping { get; internal set; }
}

internal class engine
{
    internal static bool IsHLTV()
    {
        return new()
        {


        };
    }


    internal static bool IsPaused()
    {

        return new()
        {


        };
    }
}

internal class C_BasePlayer
{
    internal static C_BasePlayer GetLocalPlayer()
    {

        return new()
        {


        };
    }

    internal void ComputeFxBlend()
    {
        return;
       
    }

    internal int DrawOverriddenViewmodel(C_BaseViewModel c_BaseViewModel, int flags)
    {
        return DrawOverriddenViewmodel(c_BaseViewModel, flags);
    }

    internal float GetFinalPredictedTime()
    {
        return new()
        {


        };
    }

    internal int GetFxBlend()
    {
        return new()
        {


        };
    }

    internal bool IsOverridingViewmodel()
    {
        return new()
        {

        };
    }

    internal bool ViewModel_IsTransparent()
    {
       return new()
       {
           
       };
    }

    internal bool ViewModel_IsUsingFBTexture()
    {
        return new();
    }
}

internal class gpGlobals
{
    internal static float curtime;

    public static int interpolation_amount { get; internal set; }
}

internal class BaseClass
{
    internal static int DrawModel(int flags)
    {
        return DrawModel(flags);    
    }

    internal static void FireEvent(Vector3 origin, Vector3 angles, int eventId, string options)
    {
        return;
    }

    internal static void GetBoneControllers(float[] controllers)
    {
        return;
    }

    internal static int GetFxBlend()
    {
        return GetFxBlend();
    }

    internal static int InternalDrawModel(int flags)
    {
        return InternalDrawModel(flags);
    }

    internal static bool Interpolate(float currentTime)
    {
       return Interpolate(currentTime);
    }

    internal static bool IsTransparent()
    {
        return IsTransparent();
    }

    internal static void OnDataChanged(DataUpdateType updateType)
    {
        return;
    }

    internal static void PostDataUpdate(DataUpdateType updateType)
    {
        return ;
    }

    internal static bool ShouldDraw()
    {
        return ShouldDraw();
    }

    internal static bool UsesPowerOfTwoFrameBufferTexture()
    {
       return UsesPowerOfTwoFrameBufferTexture();
    }
}

internal class C_BaseCombatWeapon
{
    internal void ComputeFxBlend()
    {
        return ;
    }

    internal int DrawOverriddenViewmodel(C_BaseViewModel c_BaseViewModel, int flags)
    {
        return new();
    }

    internal int GetFxBlend()
    {
        return new();
    }

    internal object GetName()
    {
        return new();
    }

    internal void GetViewmodelBoneControllers(C_BaseViewModel c_BaseViewModel, float[] controllers)
    {
        return;
    }

    internal bool IsOverridingViewmodel()
    {
        return new();
    }

    internal bool OnFireEvent(C_BaseViewModel c_BaseViewModel, Vector3 origin, Vector3 angles, int eventId, string options)
    {
        return new();
    }

    internal void ViewModelDrawn(C_BaseViewModel c_BaseViewModel)
    {
       
    }

    internal bool ViewModel_IsTransparent()
    {
        return new();
    }

    internal bool ViewModel_IsUsingFBTexture()
    {
        return new();
    }
}

public class RenderGroup_t
{
    public static RenderGroup_t RENDER_GROUP_VIEW_MODEL_OPAQUE { get; internal set; }
}