funnygame/game/client/milmoba/player.cpp

#include "player.h"
#include "cglm/cglm.h"
#include "assetmgr.h"
#include "game.h"

void C_MOBAPlayer::Precache()
{
}


void C_MOBAPlayer::Spawn()
{
	BaseClass::Spawn();
	SetThink(Think);
	SetScale(1);
};

void C_MOBAPlayer::Think( float fDelta )
{

	C_MOBAPlayer *pPlayerEntity = (C_MOBAPlayer*)UTIL_GetLocalPlayer();

	m_vMovementVector.z = m_bIsBack - m_bIsForward;
	m_vMovementVector.x = m_bIsRight - m_bIsLeft;

	if (pPlayerEntity == this)
	{
	}
	m_pLeftHand = (C_MOBAPlayerHandController*)EntitySystem()->GetEntityByIndex(m_leftHandId);
	m_pRightHand = (C_MOBAPlayerHandController*)EntitySystem()->GetEntityByIndex(m_rightHandId);
	BaseClass::Think(fDelta);
};

LINK_ENTITY_TO_CLASS(player, C_MOBAPlayer)

BEGIN_DATADESC(C_MOBAPlayer)
END_DATADESC()

IMPLEMENT_RECV_DT(C_MOBAPlayer)
	NetPropInt(m_leftHandId),
	NetPropInt(m_rightHandId),
END_RECV_DT()

IMPLEMENT_SEND_DT(C_MOBAPlayer)
	NetPropFloat3(m_vMovementVector),
END_SEND_DT()


static void IN_ForwardDown( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsForward = true;
}
static ConCommand startforward("+forward", IN_ForwardDown);

static void IN_ForwardUp( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsForward = false;
}
static ConCommand endforward("-forward", IN_ForwardUp);

static void IN_BackDown( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsBack = true;
}
static ConCommand startback("+back", IN_BackDown);

static void IN_BackUp( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsBack = false;
}
static ConCommand endback("-back", IN_BackUp);

static void IN_RightDown( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsRight = true;
}
static ConCommand startright("+right", IN_RightDown);

static void IN_RightUp( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsRight = false;
}
static ConCommand endright("-right", IN_RightUp);


static void IN_LeftDown( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsLeft = true;
}
static ConCommand startleft("+left", IN_LeftDown);

static void IN_LeftUp( int c, char **v ) {
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	((C_MOBAPlayer*)pPlayer)->m_bIsLeft = false;
}
static ConCommand endleft("-left", IN_LeftUp);

void Game_OnGameAxis( EInputDeviceType eDevice, EInputAxis eAxis, float fValue )
{	


}

static ConVar m_pitch("m_pitch", "0.022", FCVAR_CLIENTDLL);
static ConVar m_yaw("m_yaw", "0.022", FCVAR_CLIENTDLL);
static ConVar sens("sens", "3", FCVAR_CLIENTDLL);

void Game_OnGameAxisDiff( EInputDeviceType eDevice, EInputAxis eAxis, float fValue )
{
	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	switch(eAxis)
	{
	case k_EInputAxis_MouseY:
		((C_MOBAPlayer*)pPlayer)->m_fPitch -= glm_rad(fValue * m_pitch.GetFloat() * sens.GetFloat());
		break;
	case k_EInputAxis_MouseX:
		((C_MOBAPlayer*)pPlayer)->m_fYaw -= glm_rad(fValue * m_yaw.GetFloat() * sens.GetFloat());
		break;
	default:
		break;
	}
}


void C_MOBAPlayerHandController::Precache()
{

	m_hNormal = g_pAssetManager->LoadModel("game/core/models/hand.fmdl");
	m_pNormalModel = g_pAssetManager->GetModelByIndex(m_hNormal);
	m_hSqueezed = g_pAssetManager->LoadModel("game/core/models/sphere.fmdl");
	m_pSqueezedModel = g_pAssetManager->GetModelByIndex(m_hSqueezed);
	m_pModel = m_pNormalModel;
	m_pMesh = g_pAssetManager->GetMeshByIndex(m_pModel->m_hMesh)->m_pMesh;
	m_pInstance = g_pWorldRenderer->CreateInstance(m_pMesh);
}


void C_MOBAPlayerHandController::Spawn()
{
	BaseClass::Spawn();
	SetThink(Think);
};

void C_MOBAPlayerHandController::Think( float fDelta )
{
	if (m_fSqueeze != m_fPreviousSqueeze)
	{
		if (m_fSqueeze > 0.5 && m_fPreviousSqueeze > 0.5)
			goto draw;
		if (m_fSqueeze <= 0.5 && m_fPreviousSqueeze <= 0.5)
			goto draw;

		if (m_pInstance)
			g_pWorldRenderer->DestroyMeshInstance(m_pMesh, m_pInstance);

		if (m_fSqueeze > 0.5)
			m_pModel = m_pSqueezedModel;
		else
			m_pModel = m_pNormalModel;
		m_pMesh = g_pAssetManager->GetMeshByIndex(m_pModel->m_hMesh)->m_pMesh;
		m_pInstance = g_pWorldRenderer->CreateInstance(m_pMesh);
	}

draw:
	if (m_pInstance)
	{
		CBaseMaterial *pMat = g_pAssetManager->GetMaterialByIndex(m_pModel->m_hMaterial)->m_pLayout;
		m_pInstance->SetPosition(m_vDesiredHandPosition);
		m_pInstance->SetRotation(m_vDesiredHandRotation);
		m_pInstance->SetScale({0.025, 0.025, 0.025});
		m_pInstance->SetMaterial(pMat);

	}

	m_fPreviousSqueeze = m_fSqueeze;
}
C_MOBAPlayerHandController::~C_MOBAPlayerHandController()
{
	if (m_pInstance)
		g_pWorldRenderer->DestroyMeshInstance(m_pMesh, m_pInstance);
	g_pAssetManager->UnrefModel(m_hNormal);
	g_pAssetManager->UnrefModel(m_hSqueezed);

}

LINK_ENTITY_TO_CLASS(player_hand_controller, C_MOBAPlayerHandController)

BEGIN_DATADESC(C_MOBAPlayerHandController)
END_DATADESC()

IMPLEMENT_RECV_DT(C_MOBAPlayerHandController)
END_RECV_DT()

IMPLEMENT_SEND_DT(C_MOBAPlayerHandController)
END_SEND_DT()

void XRInputCallback( IXRController *pController, EXRInputType_t eType, const char *szType, EXRInputActionType_t action, EXRInputValue_t value )
{

	C_BaseEntity *pPlayer = UTIL_GetLocalPlayer();
	if (!pPlayer)
		return;
	if (!dynamic_cast<C_MOBAPlayer*>(pPlayer))
		return;
	C_MOBAPlayer *p = (C_MOBAPlayer*)pPlayer;
	C_MOBAPlayerHandController *pCon = NULL;

	if (pController->GetControllerSide() == k_EXRController_Left)
		pCon = p->m_pLeftHand;

	if (pController->GetControllerSide() == k_EXRController_Right)
		pCon = p->m_pRightHand;

	if (pCon == NULL)
		return;

	switch (eType) {
	case k_EXRInput_Grip:
		if (action == k_EXRInputAction_Pose)
		{
			pCon->m_vDesiredHandPosition = value.pose.pos;
			pCon->m_vDesiredHandRotation = value.pose.rot;
		}
		break;
	case k_EXRInput_Squeeze:
		if (action == k_EXRInputAction_Value)
		{
			pCon->m_fSqueeze = value.f32.value;
		}
		break;
	default:
		break;
	}

}