update player camera API

Author: Hedgefog

api_player_camera.sma

@@ -5,12 +5,19 @@
 #include <hamsandwich>
 #include <xs>
 
-new g_rgpPlayerCamera[MAX_PLAYERS];
-new Float:g_rgflPlayerCameraDistance[MAX_PLAYERS];
-new Float:g_rgflPlayerCameraAngles[MAX_PLAYERS][3];
-new Float:g_rgflPlayerCamerOffset[MAX_PLAYERS][3];
-new Float:g_rgflPlayerCameraThinkDelay[MAX_PLAYERS];
-new Float:g_rgflPlayerCameraNextThink[MAX_PLAYERS];
+new g_rgpPlayerCamera[MAX_PLAYERS + 1];
+new Float:g_rgflPlayerCameraDistance[MAX_PLAYERS + 1];
+new Float:g_rgflPlayerCameraAngles[MAX_PLAYERS + 1][3];
+new Float:g_rgflPlayerCameraOffset[MAX_PLAYERS + 1][3];
+new bool:g_rgbPlayerCameraAxisLock[MAX_PLAYERS + 1][3];
+new Float:g_rgflPlayerCameraThinkDelay[MAX_PLAYERS + 1];
+new Float:g_rgflPlayerCameraNextThink[MAX_PLAYERS + 1];
+new g_pPlayerTargetEntity[MAX_PLAYERS + 1];
+
+new g_fwActivate;
+new g_fwDeactivate;
+new g_fwActivated;
+new g_fwDeactivated;
 
 new g_iszTriggerCameraClassname;
 
@@ -23,10 +30,15 @@ public plugin_precache() {
 }
 
 public plugin_init() {
-    register_plugin("[API] Player Camerea", "1.0.0", "Hedgehog Fog");
+  register_plugin("[API] Player Camera", "1.0.0", "Hedgehog Fog");
 
-    RegisterHamPlayer(Ham_Spawn, "HamHook_Player_Spawn_Post", .Post = 1);
-    RegisterHamPlayer(Ham_Player_PreThink, "HamHook_Player_PreThink_Post", .Post = 1);
+  RegisterHamPlayer(Ham_Spawn, "HamHook_Player_Spawn_Post", .Post = 1);
+  RegisterHamPlayer(Ham_Player_PreThink, "HamHook_Player_PreThink_Post", .Post = 1);
+
+  g_fwActivate = CreateMultiForward("PlayerCamera_Fw_Activate", ET_STOP, FP_CELL);
+  g_fwDeactivate = CreateMultiForward("PlayerCamera_Fw_Deactivate", ET_STOP, FP_CELL);
+  g_fwActivated = CreateMultiForward("PlayerCamera_Fw_Activated", ET_IGNORE, FP_CELL);
+  g_fwDeactivated = CreateMultiForward("PlayerCamera_Fw_Deactivated", ET_IGNORE, FP_CELL);
 }
 
 public plugin_natives() {
@@ -37,7 +49,9 @@ public plugin_natives() {
   register_native("PlayerCamera_SetOffset", "Native_SetOffset");
   register_native("PlayerCamera_SetAngles", "Native_SetAngles");
   register_native("PlayerCamera_SetDistance", "Native_SetDistance");
+  register_native("PlayerCamera_SetAxisLock", "Native_SetAxisLock");
   register_native("PlayerCamera_SetThinkDelay", "Native_SetThinkDelay");
+  register_native("PlayerCamera_SetTargetEntity", "Native_SetTargetEntity");
 }
 
 public bool:Native_Activate(iPluginId, iArgc) {
@@ -83,13 +97,29 @@ public Native_SetDistance(iPluginId, iArgc) {
   SetCameraDistance(pPlayer, flDistance);
 }
 
+public Native_SetAxisLock(iPluginId, iArgc) {
+  new pPlayer = get_param(1);
+  new bool:bLockPitch = bool:get_param(2);
+  new bool:bLockYaw = bool:get_param(3);
+  new bool:bLockRoll = bool:get_param(4);
+
+  SetAxisLock(pPlayer, bLockPitch, bLockYaw, bLockRoll);
+}
+
 public Native_SetThinkDelay(iPluginId, iArgc) {
   new pPlayer = get_param(1);
   new Float:flThinkDelay = get_param_f(2);
 
   SetCameraThinkDelay(pPlayer, flThinkDelay);
 }
 
+public Native_SetTargetEntity(iPluginId, iArgc) {
+  new pPlayer = get_param(1);
+  new pTarget = get_param(2);
+
+  SetCameraTarget(pPlayer, pTarget);
+}
+
 public HamHook_Player_Spawn_Post(pPlayer) {
   ReattachCamera(pPlayer);
 }
@@ -100,7 +130,9 @@ public HamHook_Player_PreThink_Post(pPlayer) {
 
 public client_connect(pPlayer) {
   g_rgpPlayerCamera[pPlayer] = -1;
+  SetCameraTarget(pPlayer, pPlayer);
   SetCameraDistance(pPlayer, 200.0);
+  SetAxisLock(pPlayer, false, false, false);
   SetCameraAngles(pPlayer, Float:{0.0, 0.0, 0.0});
   SetCameraOffset(pPlayer, Float:{0.0, 0.0, 0.0});
   SetCameraThinkDelay(pPlayer, 0.01);
@@ -115,27 +147,42 @@ ActivatePlayerCamera(pPlayer) {
     return;
   }
 
+  new iResult = 0; ExecuteForward(g_fwActivate, iResult, pPlayer);
+  if (iResult != PLUGIN_CONTINUE) return;
+
   g_rgpPlayerCamera[pPlayer] = CreatePlayerCamera(pPlayer);
   g_rgflPlayerCameraNextThink[pPlayer] = 0.0;
 
   engfunc(EngFunc_SetView, pPlayer, g_rgpPlayerCamera[pPlayer]);
+
+  static Float:vecOrigin[3];
+  pev(g_pPlayerTargetEntity[pPlayer], pev_origin, vecOrigin);
+  engfunc(EngFunc_SetOrigin, g_rgpPlayerCamera[pPlayer], vecOrigin);
+
+  ExecuteForward(g_fwActivated, _, pPlayer);
 }
 
 DeactivatePlayerCamera(pPlayer) {
   if (g_rgpPlayerCamera[pPlayer] == -1) {
     return;
   }
 
+  new iResult = 0; ExecuteForward(g_fwDeactivate, iResult, pPlayer);
+  if (iResult != PLUGIN_CONTINUE) return;
+
   engfunc(EngFunc_RemoveEntity, g_rgpPlayerCamera[pPlayer]);
   g_rgpPlayerCamera[pPlayer] = -1;
+  g_pPlayerTargetEntity[pPlayer] = pPlayer;
 
   if (is_user_connected(pPlayer)) {
     engfunc(EngFunc_SetView, pPlayer, pPlayer);
   }
+
+  ExecuteForward(g_fwDeactivated, _, pPlayer);
 }
 
 SetCameraOffset(pPlayer, const Float:vecOffset[3]) {
-  xs_vec_copy(vecOffset, g_rgflPlayerCamerOffset[pPlayer]);
+  xs_vec_copy(vecOffset, g_rgflPlayerCameraOffset[pPlayer]);
 }
 
 SetCameraAngles(pPlayer, const Float:vecAngles[3]) {
@@ -146,76 +193,91 @@ SetCameraDistance(pPlayer, Float:flDistance) {
   g_rgflPlayerCameraDistance[pPlayer] = flDistance;
 }
 
+SetAxisLock(pPlayer, bool:bLockPitch, bool:bLockYaw, bool:bLockRoll) {
+  g_rgbPlayerCameraAxisLock[pPlayer][0] = bLockPitch;
+  g_rgbPlayerCameraAxisLock[pPlayer][1] = bLockYaw;
+  g_rgbPlayerCameraAxisLock[pPlayer][2] = bLockRoll;
+}
+
 SetCameraThinkDelay(pPlayer, Float:flThinkDelay) {
   g_rgflPlayerCameraThinkDelay[pPlayer] = flThinkDelay;
 }
 
+SetCameraTarget(pPlayer, pTarget) {
+  g_pPlayerTargetEntity[pPlayer] = pTarget;
+}
+
 CreatePlayerCamera(pPlayer) {
-    new pCamera = engfunc(EngFunc_CreateNamedEntity, g_iszTriggerCameraClassname);
+  new pCamera = engfunc(EngFunc_CreateNamedEntity, g_iszTriggerCameraClassname);
 
-    set_pev(pCamera, pev_classname, "trigger_camera");
-    set_pev(pCamera, pev_modelindex, g_iCameraModelIndex);
-    set_pev(pCamera, pev_owner, pPlayer);
-    set_pev(pCamera, pev_solid, SOLID_NOT);
-    set_pev(pCamera, pev_movetype, MOVETYPE_FLY);
-    set_pev(pCamera, pev_rendermode, kRenderTransTexture);
+  set_pev(pCamera, pev_classname, "trigger_camera");
+  set_pev(pCamera, pev_modelindex, g_iCameraModelIndex);
+  set_pev(pCamera, pev_owner, pPlayer);
+  set_pev(pCamera, pev_solid, SOLID_NOT);
+  set_pev(pCamera, pev_movetype, MOVETYPE_FLY);
+  set_pev(pCamera, pev_rendermode, kRenderTransTexture);
 
-    return pCamera;
+  return pCamera;
 }
 
 PlayerCameraThink(pPlayer) {
-    if (g_rgflPlayerCameraNextThink[pPlayer] > get_gametime()) {
-        return;
-    }
+  if (g_rgflPlayerCameraNextThink[pPlayer] > get_gametime()) {
+    return;
+  }
 
-    g_rgflPlayerCameraNextThink[pPlayer] = get_gametime() + g_rgflPlayerCameraThinkDelay[pPlayer];
+  g_rgflPlayerCameraNextThink[pPlayer] = get_gametime() + g_rgflPlayerCameraThinkDelay[pPlayer];
 
-    if (g_rgpPlayerCamera[pPlayer] == -1) {
-        return;
-    }
+  if (g_rgpPlayerCamera[pPlayer] == -1) {
+    return;
+  }
 
-    if (!is_user_alive(pPlayer)) {
-        return;
-    }
+  if (!is_user_alive(pPlayer)) {
+    return;
+  }
 
-    static Float:vecOrigin[3];
-    pev(pPlayer, pev_origin, vecOrigin);
-    xs_vec_add(vecOrigin, g_rgflPlayerCamerOffset[pPlayer], vecOrigin);
+  static Float:vecOrigin[3];
+  pev(g_pPlayerTargetEntity[pPlayer], pev_origin, vecOrigin);
+  xs_vec_add(vecOrigin, g_rgflPlayerCameraOffset[pPlayer], vecOrigin);
 
-    static Float:vecAngles[3];
-    pev(pPlayer, pev_angles, vecAngles);
-    vecAngles[0] = vecAngles[2] = 0.0;
-    xs_vec_add(vecAngles, g_rgflPlayerCameraAngles[pPlayer], vecAngles);
+  static Float:vecAngles[3];
+  pev(g_pPlayerTargetEntity[pPlayer], pev_v_angle, vecAngles);
+  for (new iAxis = 0; iAxis < 3; ++iAxis) {
+    if (g_rgbPlayerCameraAxisLock[pPlayer][iAxis]) {
+      vecAngles[iAxis] = 0.0;
+    }
+  }
 
-    static Float:vecBack[3];
-    angle_vector(vecAngles, ANGLEVECTOR_FORWARD, vecBack);
-    xs_vec_neg(vecBack, vecBack);
+  xs_vec_add(vecAngles, g_rgflPlayerCameraAngles[pPlayer], vecAngles);
 
-    static Float:vecVelocity[3];
-    pev(pPlayer, pev_velocity, vecVelocity);
+  static Float:vecBack[3];
+  angle_vector(vecAngles, ANGLEVECTOR_FORWARD, vecBack);
+  xs_vec_neg(vecBack, vecBack);
 
-    static Float:vecCameraOrigin[3];
-    for (new i = 0; i < 3; ++i) {
-        vecCameraOrigin[i] = vecOrigin[i] + (vecBack[i] * g_rgflPlayerCameraDistance[pPlayer]);
-    }
+  static Float:vecVelocity[3];
+  pev(g_pPlayerTargetEntity[pPlayer], pev_velocity, vecVelocity);
 
-    new pTr = create_tr2();
-    engfunc(EngFunc_TraceLine, vecOrigin, vecCameraOrigin, IGNORE_MONSTERS, pPlayer, pTr);
+  static Float:vecCameraOrigin[3];
+  for (new i = 0; i < 3; ++i) {
+    vecCameraOrigin[i] = vecOrigin[i] + (vecBack[i] * g_rgflPlayerCameraDistance[pPlayer]);
+  }
+
+  new pTr = create_tr2();
+  engfunc(EngFunc_TraceLine, vecOrigin, vecCameraOrigin, IGNORE_MONSTERS, pPlayer, pTr);
 
-    static Float:flFraction;
-    get_tr2(pTr, TR_flFraction, flFraction);
+  static Float:flFraction;
+  get_tr2(pTr, TR_flFraction, flFraction);
 
-    free_tr2(pTr);
+  free_tr2(pTr);
 
-    if(flFraction != 1.0) { 
-      for (new i = 0; i < 3; ++i) {
-        vecCameraOrigin[i] = vecOrigin[i] + (vecBack[i] * (g_rgflPlayerCameraDistance[pPlayer] * flFraction));
-      }
+  if(flFraction != 1.0) { 
+    for (new i = 0; i < 3; ++i) {
+      vecCameraOrigin[i] = vecOrigin[i] + (vecBack[i] * (g_rgflPlayerCameraDistance[pPlayer] * flFraction));
     }
+  }
 
-    set_pev(g_rgpPlayerCamera[pPlayer], pev_origin, vecCameraOrigin);
-    set_pev(g_rgpPlayerCamera[pPlayer], pev_angles, vecAngles);
-    set_pev(g_rgpPlayerCamera[pPlayer], pev_velocity, vecVelocity);
+  set_pev(g_rgpPlayerCamera[pPlayer], pev_origin, vecCameraOrigin);
+  set_pev(g_rgpPlayerCamera[pPlayer], pev_angles, vecAngles);
+  set_pev(g_rgpPlayerCamera[pPlayer], pev_velocity, vecVelocity);
 }
 
 ReattachCamera(pPlayer) {