Library 3DTryg

AbyssMorgan

Include contain professional functions for manipulating (coordinates / rotations / vectors / arc / areas / offset) supported (2D / 3D)

Videos:
- Knife Shoot
- EngineV6
- EngineX
- Missile Launch
- Vehicle Missile Launch (ColAndreas Version)
- GetGroundRotation
- GetPlayerCollisionFlags (ColAndreas)
- Marica Mortar V1
- Heavy Marica Mortar
- Acid Renia (FCNPC)
- Beta Interceptor (FCNPC)
- GoToPlayerOnGroundCol (FCNPC)
- IsElementOnPlayerScreen (ColAndreas)
- Arc Points
- Missile Launcher Aim Player
- GetRandomPointOnSphericalSector
- Vehicle Missile Congreve Rocket
- Magic Wand
- Vehicle Parachute
- Portal Gun #1
- Portal Gun #2
- Marica Mortar V2
- Stingers (Cops and Robbers)
- NPC Driver Eye
- PET SAR v1.0
- Vehicle Speed Control
- Prototype Grenade Detection

Code:
3DTryg.inc

 Copyright © 2021 Abyss Morgan. All rights reserved.

 Contributors: Crayder, IllidanS4, Nero_3D, RyDeR, Zoutdaxv, hesambia, Neil Lamoureux, Ivan_Ino, Ralfie, Unrea1, Katarina Calzaghe, $continue$

 Mr.Reus

 Website: https://adm.ct8.pl

 Plugins: ColAndreas, YSF, Streamer, FCNPC, VehicleStreamer

 Internal Modules: Actor, VehicleCollision, PlayerCollision, ActorCollision, Draw3D, CatchItems, GrenadeDetection

 File Version: 5.3.0

 ColAndreas Version: 1.5.0

 YSF Version: R19 (kurta999)

 Streamer Version: 2.9.5

 VehicleStreamer Version: 2.9.4

 FCNPC Version: 2.0.0

 Foreach Types:

 1. FoxForeach

 2. StandaloneForeach

 3. YSI Foreach

 4. GetPlayerPoolSize

 Compiler Options:

 DISABLE_3D_TRYG_INIT            //Use before 3DTryg.inc for disable ColAndreas Auto Init

 DISABLE_3D_TRYG_ACTOR           //Use before 3DTryg.inc for disable Actors Module

 DISABLE_3D_TRYG_FOREACH_FOX     //Use before 3DTryg.inc for disable FoxForeach Module

 DISABLE_3D_TRYG_FOREACH_STAND   //Use before 3DTryg.inc for disable StandaloneForeach Module

 DISABLE_3D_TRYG_FOREACH_YSI     //Use before 3DTryg.inc for disable YSI Foreach Module

 DISABLE_3D_TRYG_COLANDREAS      //Use before 3DTryg.inc for disable ColAndreas Module

 DISABLE_3D_TRYG_YSF             //Use before 3DTryg.inc for disable YSF Module

 DISABLE_3D_TRYG_STREAMER        //Use before 3DTryg.inc for disable Streamer Module

 DISABLE_3D_TRYG_FCNPC           //Use before 3DTryg.inc for disable FCNPC Module

 DISABLE_3D_TRYG_VEHSTREAMER     //Use before 3DTryg.inc for disable VehicleStreamer Module

 ENABLE_3D_TRYG_YSI_SUPPORT      //Use before 3DTryg.inc for enable YSI Support (use only when 3DTryg say error for this)

 ENABLE_3D_TRYG_DRAW3D           //Use before 3DTryg.inc for enable Draw3D Module

 ENABLE_3D_TRYG_CATCH_ITEMS      //Use before 3DTryg.inc for enable CatchItems Module

 ENABLE_3D_TRYG_GRENADEDETECTION //Use before 3DTryg.inc for enable GrenadeDetection Module

 ENABLE_3D_TRYG_VEHICLECOL       //Use before 3DTryg.inc for enable VehicleCollision Module

 ENABLE_3D_TRYG_PLAYERCOL        //Use before 3DTryg.inc for enable PlayerCollision Module

 ENABLE_3D_TRYG_ACTORCOL         //Use before 3DTryg.inc for enable ActorCollision Module

 Complementary Functions:

 Float:sqrtN(Float:value,Float:exponent);

 abs(value);

 Float:fabs(Float:value);

 power(value,Float:exponent);

 IsEven(value);

 Float:Tryg3D::RandomFloat(Float:min,Float:max,accuracy=4);

 Internal Functions:

 single_clock(max,id); //For Random::PointOnClock parameter rz

 even_clock(max,id); //For Random::PointOnClock parameter rz

 uneven_clock(max,id); //For Random::PointOnClock parameter rz

 NLTZ(value); //NotLessThanZero

 NMTZ(value); //NotMoreThanZero

 NLTZF(Float:value); //NotLessThanZeroFloat

 NMTZF(Float:value); //NotMoreThanZeroFloat

 NLTV(value,min); //NotLessThanValue

 NMTV(value,max); //NotMoreThanValue

 NLTVF(Float:value,Float:min); //NotLessThanValueFloat

 NMTVF(Float:value,Float:max); //NotMoreThanValueFloat

 Tryg3D::CompressRotation(Float:rotation);

 Tryg3D::DeCompressRotation(Float:rotation);

 Tryg3D::IsRotationTest(Float:rotation,Float:r_min,Float:r_max);

 Tryg3D::GivePlayerDamage(targetid,Float:amount,playerid,weaponid,bodypart);

 Tryg3D::GetWeaponDamage(weaponid);

 Tryg3D::SwapInt(variable1,variable2);

 Tryg3D::IsPlayerSpawned(playerid);

 Tryg3D::GetActiveTime();

 General Functions:

 CountPlayers(bool:isplayer=true,bool:isnpc=true);

 CountActors();

 CountVisibleActors(playerid);

 CountVisibleVehicles(playerid);

 CountVisiblePlayers(playerid,bool:isplayer=true,bool:isnpc=true);

 RecoilFloat(Float:value,Float:recoil);

 RecoilVector(&Float:vx,&Float:vy,&Float:vz,Float:sx,Float:sy,Float:sz);

 Float:ShiftDegreeToRadian(Float:deg);

 Float:ShiftDegreeToRadianEx(Float:deg);

 Float:ShiftDegreeToGrades(Float:deg);

 Float:ShiftRadianToDegree(Float:rad);

 Float:ShiftRadianToDegreeEx(Float:rad);

 Float:ShiftRadianToGrades(Float:rad);

 Float:ShiftGradesToDegree(Float:grad);

 Float:ShiftGradesToRadian(Float:grad);

 GetRandomHit(Float:x,Float:y,Float:z,range,&Float:tx,&Float:ty,&Float:tz);

 Float:GetDistanceBetweenPoints1D(Float:x1,Float:x2);

 Float:GetDistanceBetweenPoints2D(Float:x1,Float:y1,Float:x2,Float:y2);

 Float:GetDistanceBetweenPoints3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2);

 GetPointInFront2D(Float:x,Float:y,Float:rz,Float:radius,&Float:tx,&Float:ty);

 GetPointInFront3D(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 GetPointInFront3DEx(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Float:GetPointInFrontOfPlayer(playerid,&Float:tx,&Float:ty,Float:radius);

 Float:GetPointInFrontOfCamera2D(playerid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfCamera3D(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 GetRotationFor2Point2D(Float:x,Float:y,Float:tx,Float:ty,&Float:rz);

 GetRotationFor2Point3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:rx,&Float:rz);

 GetMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:speed,&rtime=0);

 GetSpeedForMoveTime(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:speed,rtime);

 GetVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);

 Float:GetPointInFrontOfVehicle2D(vehicleid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfVehicle3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 GetPlayerCameraRotation(playerid,&Float:rx,&Float:rz);

 Float:GetPlayerCameraZAngle(playerid,&Float:rz=0.0);

 GetPointFor2Point2D(Float:x1,Float:y1,Float:x2,Float:y2,Float:percent_size,&Float:tx,&Float:ty);

 GetPointFor2Point3D(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2,Float:percent_size,&Float:tx,&Float:ty,&Float:tz);

 GetPointFor2Point2DEx(Float:x1,Float:y1,Float:x2,Float:y2,Float:distance,&Float:tx,&Float:ty);

 GetPointFor2Point3DEx(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2,Float:distance,&Float:tx,&Float:ty,&Float:tz);

 ShiftVectorToRotation(Float:vx,Float:vy,Float:vz,&Float:rx,&Float:rz);

 ShiftRotationToVector(Float:rx,Float:rz,&Float:vx,&Float:vy,&Float:vz);

 GetPointToPointVector(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz);

 IsPointBetween2Points2D(Float:px,Float:py,Float:xA,Float:yA,Float:xB,Float:yB);

 IsPointBetween2Points3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB);

 IsProbable(chance);

 IsProbableEx(chance,poolsize); //by default IsProbable using 100

 Float:CalculatePercent(Float:value,Float:maxvalue);

 Float:GetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);

 Float:SetPlayerTargetAngle(playerid,Float:x,Float:y,&Float:rz=0.0);

 Float:GetPlayerTargetPlayerAngle(playerid,targetid,&Float:rz=0.0);

 Float:SetPlayerTargetPlayerAngle(playerid,targetid,&Float:rz=0.0);

 Float:GetVehicleSpeed(vehicleid);

 SetVehicleSpeed(vehicleid,Float:speed);

 Float:GetPlayerSpeed(playerid);

 GetVehicleFlags(vehicleid);

 GetVehicleDefaultFlagsByModel(modelid);

 GetVehicleFlagsByModel(modelid);

 SetVehicleFlagsByModel(modelid,value);

 ToggleVehicleModelFlag(modelid,flag,bool:toggle);

 IsVehicleFlag(value,flag);

 GetWeaponShotPos(playerid,hittype,&Float:fx,&Float:fy,&Float:fz);

 GetPlayerCameraLookAt(playerid,&Float:x,&Float:y,&Float:z);

 IsPlayerLookAtSky(playerid);

 GetQuatUpVector(Float:qw,Float:qx,Float:qy,Float:qz,&Float:vx,&Float:vy,&Float:vz);

 Float:GetLineSize2D(Float:points[][2],maxpoints=sizeof(points));

 Float:GetLineSize3D(Float:points[][3],maxpoints=sizeof(points));

 IsVehicleInRangeOfPoint(vehicleid,Float:range,Float:x,Float:y,Float:z);

 IsActorInRangeOfPoint(actorid,Float:range,Float:x,Float:y,Float:z);

 ShiftLineRotation(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,Float:rx,Float:ry,Float:rz,&Float:nX,&Float:nY,&Float:nZ);

 ShiftLineRotationVector(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,Float:rx,Float:ry,Float:rz,&Float:nX,&Float:nY,&Float:nZ);

 Float:GetEllipseRadius(Float:x,Float:y,Float:angle);

 GetArcPoints3D(Float:x,Float:y,Float:z,Float:tx,Float:ty,Float:tz,Float:ry,Float:height,Float:points[][3],max_points=sizeof(points));

 Float:GetDistanceFromPointToLine(Float:px,Float:py,Float:pz,Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:iX=0.0,&Float:iY=0.0,&Float:iZ=0.0);

 Float:GetDistanceFromPointToLineEx(Float:px,Float:py,Float:pz,Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:iX=0.0,&Float:iY=0.0,&Float:iZ=0.0);

 GetNearest2DPointOnPolygon(const Float:polygon_points[],Float:x,Float:y,&Float:tx,&Float:ty,maxpoints = sizeof(polygon_points));

 ShiftOffsetToPosition(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:offset_x,Float:offset_y,Float:offset_z,&Float:tx,&Float:ty,&Float:tz);

 ShiftPositionToOffset(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,&Float:offset_x,&Float:offset_y,&Float:offset_z,Float:tx,Float:ty,Float:tz);

 Tryg3D::EulerToQuat(Float:rx,Float:ry,Float:rz,&Float:qw,&Float:qx,&Float:qy,&Float:qz);

 Tryg3D::QuatToEuler(&Float:rx,&Float:ry,&Float:rz,Float:qw,Float:qx,Float:qy,Float:qz);

 ShiftVectorRotation(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,&Float:tx,&Float:ty,&Float:tz);

 GetCube3DPoint(OrientationCube3D:orientation,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);

 IsPlayerFakeSpectating(playerid,bool:force_disable=true);

 GenerateGangZone(Float:x,Float:y,Float:radius,&Float:minx,&Float:miny,&Float:maxx,&Float:maxy);

 Float:GetCameraTargetDistance(Float:CamX,Float:CamY,Float:CamZ,Float:ObjX,Float:ObjY,Float:ObjZ,Float:FrX,Float:FrY,Float:FrZ);

 IsPlayerAimingAt(playerid,Float:x,Float:y,Float:z,Float:radius);

 IPL_CreateObject(modelid,Float:x,Float:y,Float:z,Float:qx,Float:qy,Float:qz,Float:qw,Float:drawdistance=0.0);

 bool:IsPolygonClosed(const Float:points[],maxpoints = sizeof(points));

 bool:IsValidPolygon(const Float:points[],maxpoints = sizeof(points));

 Tryg3D::GetOrientation(Float:angle);

 Tryg3D::GetOrientationName(orientation_name[],Float:angle,bool:as_compass=false,maxdest = sizeof(orientation_name));

 Cast3D functions:

 Cast3D::Explosion(Float:x,Float:y,Float:z,type,Float:radius,worldid=-1,interiorid=-1,playerid=-1,Float:distance=200.0);

 Cast3D::ExplosionDMG(Float:x,Float:y,Float:z,type,Float:radius,worldid=-1,interiorid=-1,playerid=-1,Float:distance=200.0,Float:damage=82.5,Float:vehicle_damage=82.5,byplayerid=INVALID_PLAYER_ID,ignore_vehicle = INVALID_VEHICLE_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);

 Cast3D::ExplosionRangeDMG(Float:x,Float:y,Float:z,type,Float:radius,worldid = -1,interiorid = -1,playerid = -1,Float:distance = 200.0,Float:min_damage=10.0,Float:max_damage=82.5,Float:min_vehicle_damage=50.0,Float:max_vehicle_damage=250.0,byplayerid=INVALID_PLAYER_ID,ignore_vehicle = INVALID_VEHICLE_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);

 Cast3D::Damage(weaponid,bodypart,Float:damage,Float:vehicle_damage,Float:x,Float:y,Float:z,Float:radius,worldid=-1,interiorid=-1,playerid=-1,byplayerid=INVALID_PLAYER_ID);

 Cast3D::Gravity(Float:x,Float:y,Float:z,Float:radius,Float:power = 1.0,worldid = -1,interiorid = -1,playerid = -1,byplayerid = INVALID_PLAYER_ID);

 Area check functions:

 Area::PointInCircle(Float:px,Float:py,Float:x,Float:y,Float:radius);

 Area::PointInCylinder2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,Float:radius);

 Area::PointInCylinder3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius);

 Area::PointInSphere(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:radius);

 Area::PointInRectangle(Float:x,Float:y,Float:minx,Float:miny,Float:maxx,Float:maxy);

 Area::PointInCube(Float:x,Float:y,Float:z,Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz);

 Area::PointInPolygon(Float:x,Float:y,Float:points[],maxpoints=sizeof(points));

 Area::PointInCircularSector(Float:px,Float:py,Float:x,Float:y,Float:rz,Float:radius,Float:view_angle);

 Area::PointInSphericalSector(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz);

 Area::PointInCone2D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b);

 Area::PointInCone3D(Float:px,Float:py,Float:pz,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b);

 Area::PointInCube3D(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z);

 Area::PointInEllipse(Float:px,Float:py,Float:cx,Float:cy,Float:size_x,Float:size_y);

 Area::PointInEllipticalCylinder(Float:px,Float:py,Float:pz,Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y);

 Area::PointInSphericalSectorEx(Float:px,Float:py,Float:pz,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);

 Area get random point functions (IN)

 Random::PointInCircle(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty);

 Random::PointInCylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInCylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInSphere(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInRectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,&Float:tx,&Float:ty);

 Random::PointInCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInPolygon(Float:points[],&Float:tx,&Float:ty,maxpoints = sizeof(points), max_iterations = 10000);

 Random::PointInCircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,&Float:tx,&Float:ty);

 Random::PointInSphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInCone2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b,&Float:tx,&Float:ty,&Float:tz)

 Random::PointInCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInCube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);

 Random::PointInEllipse(Float:cx,Float:cy,Float:size_x,Float:size_y,&Float:tx,&Float:ty);

 Random::PointInEllipticalCyl2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,&Float:tx,&Float:ty,&Float:tz);

 Area get random point functions (ON)

 Random::PointOnCircle(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty);

 Random::PointOnCylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnCylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnSphere(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnRectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,&Float:tx,&Float:ty);

 Random::PointOnCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnCircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,&Float:tx,&Float:ty);

 Random::PointOnSphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnCone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnCube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnEllipse(Float:cx,Float:cy,Float:size_x,Float:size_y,&Float:tx,&Float:ty);

 Random::PointOnEllipticalCyl2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,&Float:tx,&Float:ty,&Float:tz);

 Random::PointOnClock(Float:x,Float:y,Float:radius,&Float:tx,&Float:ty,&Float:trz,Float:rz=INVALID_ROTATION);

 Universal Functions:

 Item::GetInvalidID(Item3D_Type:item_type);

 Item::GetPos(elementid,Item3D_Type:element_type,&Float:x,&Float:y,&Float:z);

 Item::GetVirtualWorld(elementid,Item3D_Type:element_type);

 Item::GetInterior(elementid,Item3D_Type:element_type);

 Item::GetRotationQuat(elementid,Item3D_Type:element_type,&Float:qw,&Float:qx,&Float:qy,&Float:qz);

 Item::GetUpVector(elementid,Item3D_Type:element_type,&Float:vx,&Float:vy,&Float:vz);

 Item::GetUpPos(elementid,Item3D_Type:element_type,Float:radius,&Float:x,&Float:y,&Float:z,bool:reverse=false);

 Item::GetDistance(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type);

 Item::GetDistanceFromPoint(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z);

 Item::GetToPointVector(elementid,Item3D_Type:element_type,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz);

 Item::GetRotatedVector(elementid,Item3D_Type:element_type,Float:tx,Float:ty,Float:tz,&Float:vx,&Float:vy,&Float:vz,bool:return_vector=true,Float:rx=0.0,Float:ry=0.0,Float:rz=0.0);

 Item::GetOrientationPos(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);

 Item::OnPlayerScreen(playerid,targetid,Item3D_Type:target_type=item_player,element_orientation:orientation=o_front,Float:rx=INVALID_ROTATION,Float:rz=INVALID_ROTATION,Float:vrx=VERTICAL_CAMERA_RADIUS,Float:vrz=HORIZONTAL_CAMERA_RADIUS,bool:testVW=true,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);

 Item::OnFakeScreen(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type,Float:rx,Float:rz,Float:vrx=VERTICAL_CAMERA_RADIUS,Float:vrz=HORIZONTAL_CAMERA_RADIUS,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT);

 Item::InCircle(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:radius);

 Item::InCylinder3D(elementid,Item3D_Type:element_type,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius);

 Item::InCylinder2D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:minz,Float:maxz,Float:radius);

 Item::InSphere(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:radius);

 Item::InRectangle(elementid,Item3D_Type:element_type,Float:minx,Float:miny,Float:maxx,Float:maxy);

 Item::InCube(elementid,Item3D_Type:element_type,Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz);

 Item::InPolygon(elementid,Item3D_Type:element_type,Float:points[],maxpoints=sizeof(points));

 Item::InCircularSector(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:rz,Float:radius,Float:view_angle);

 Item::InSphericalSector(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz);

 Item::InCone2D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b);

 Item::InCone3D(elementid,Item3D_Type:element_type,Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius_a,Float:radius_b);

 Item::InCube3D(elementid,Item3D_Type:element_type,Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z);

 Item::InEllipse(elementid,Item3D_Type:element_type,Float:cx,Float:cy,Float:size_x,Float:size_y);

 Item::InEllipticalCylinder2D(elementid,Item3D_Type:element_type,Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y);

 Item::InRangeOfPoint(Float:x,Float:y,Float:z,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);

 Item::IsPlayerInRange(playerid,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);

 Item::InRangeOfItem(elementid,Item3D_Type:element_type,Float:range,targetid,Item3D_Type:target_type=item_player,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_NONE);

 Universal Functions (ColAndreas):

 Item::ToItemIsWall(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type);

 Item::ToPointIsWall(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type);

 Item::GetCollisionFlags(elementid,Item3D_Type:element_type);

 Item::GetOrientationPosCol(elementid,Item3D_Type:element_type,element_orientation:orientation,Float:distance,&Float:tx,&Float:ty,&Float:tz);

 Item::IsPointInWaterOrient(elementid,Item3D_Type:element_type,Float:radius,element_orientation:orientation=o_front);

 Item::CollisionToPoint(Float:x,Float:y,Float:z,targetid,Item3D_Type:target_type,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);

 Item::CollisionToItem(elementid,Item3D_Type:element_type,targetid,Item3D_Type:target_type,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);

 Universal Functions (Streamer):

 Item::InDynamicArea(elementid,Item3D_Type:element_type,STREAMER_TAG_AREA:areaid);

 Item::GetInDynamicArea(STREAMER_TAG_AREA:areaid,Item3D_Type:element_type,element_list[],max_element=sizeof(element_list));

 Draw3D Module functions:

 Draw3D::Circle3D(Float:x,Float:y,Float:z,Float:radius,Float:points[][3],max_sector = 36,Float:rx = 90.0,Float:ry = 0.0,max_points = sizeof(points));

 Draw3D::Cylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));

 Draw3D::Sphere(Float:x,Float:y,Float:z,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));

 Draw3D::Cone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Float:points[][3],max_sector = 36,max_circles = 5,max_points = sizeof(points));

 Draw3D::Rectangle2D(Float:minx,Float:miny,Float:maxx,Float:maxy,Float:points[][2],points_per_wall = 36,max_points = sizeof(points));

 Draw3D::Cube2D(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,Float:points[][3],points_per_wall = 36,max_points = sizeof(points));

 Draw3D::Polygon2D(const Float:polygon_points[],Float:points[][2],points_per_line = 36,max_polygon_points = sizeof(polygon_points),max_points = sizeof(points));

 Catch Module functions:

 CatchItems::Circle(Float:x,Float:y,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Cylinder2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Cylinder3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Sphere(Float:x,Float:y,Float:z,Float:radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Rectangle(Float:minx,Float:miny,Float:maxx,Float:maxy,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::StreamCube(Float:minx,Float:miny,Float:minz,Float:maxx,Float:maxy,Float:maxz,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Polygon(const Float:points[],Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list),maxpoints = sizeof(points));

 CatchItems::CircularSector(Float:x,Float:y,Float:rz,Float:radius,Float:view_angle,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::SphericalSector(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Cone2D(Float:x,Float:y,Float:minz,Float:maxz,Float:radius_a,Float:radius_b,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Cone3D(Float:xA,Float:yA,Float:zA,Float:xB,Float:yB,Float:zB,Float:pointA_radius,Float:pointB_radius,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Cube3D(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:size_x,Float:size_y,Float:size_z,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::Ellipse(Float:cx,Float:cy,Float:size_x,Float:size_y,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::EllipticalCylinder2D(Float:cx,Float:cy,Float:minz,Float:maxz,Float:size_x,Float:size_y,Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::SphericalSectorEx(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,Float:vrx,Float:vrz,Item3D_Type:element_type,element_list[],ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_OBJECT,worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::PointInStream(Float:x,Float:y,Float:z,const Stream:AreaData[Stream3D]);

 CatchItems::InStream(TRYG3D_ELEMENT_TAG:elementid,Item3D_Type:element_type,const Stream:AreaData[Stream3D],worldid = -1,interiorid = -1);

 CatchItems::GetInStream(const Stream:AreaData[Stream3D],Item3D_Type:element_type,element_list[],worldid = -1,interiorid = -1,max_element=sizeof(element_list));

 CatchItems::GetStreamType(Stream:data);

 CatchItems::IsValidStream(Stream:data);

 ScreenToWorld Functions:

 ScreenToWorld(playerid,Float:screenX,Float:screenY,&Float:vX,&Float:vY,&Float:vZ);

 WorldToScreen(playerid,Float:x,Float:y,Float:z,&Float:screenX,&Float:screenY);

 ScreenToWorldCol(playerid,Float:distance,Float:screenX,Float:screenY,&Float:vX,&Float:vY,&Float:vZ);

 Tryg3D::NormCrossProduct(&Float:x,&Float:y,&Float:z,Float:v1x,Float:v1y,Float:v1z,Float:v2x,Float:v2y,Float:v2z);

 Nero_3D Rotations Functions:

 Tryg3D::GetRotationMatrixEuler(Float:matrix[][],Float:rx,Float:ry,Float:rz);

 Tryg3D::GetRotationMatrixEulerEx(Float:matrix[][],Float:rx,Float:ry,Float:rz,T3D:eulermode:mode=T3D:euler_default);

 Tryg3D::MatrixRotate(Float:matrix[][],Float:oX,Float:oY,Float:oZ,&Float:x,&Float:y,&Float:z);

 Tryg3D::QuatRotate(Float:qw,Float:qx,Float:qy,Float:qz,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz);

 Tryg3D::GetQuatFromEuler(Float:rx,Float:ry,Float:rz,&Float:qw,&Float:qx,&Float:qy,&Float:qz,T3D:eulermode:mode=T3D:euler_default);

 Tryg3D::EulerRotate(Float:rX,Float:rY,Float:rZ,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz);

 Tryg3D::EulerRotateEx(Float:rX,Float:rY,Float:rZ,Float:oX,Float:oY,Float:oZ,&Float:tx,&Float:ty,&Float:tz,T3D:eulermode:mode=T3D:euler_default);

 VehiclePartPosition Functions:

 GetVehiclePartPos(vehicleid,partid,&Float:tx,&Float:ty,&Float:tz,Float:offset_x=0.0,Float:offset_y=0.0,Float:offset_z=0.0);

 GetDynamicVehiclePartPos(vehicleid,partid,&Float:tx,&Float:ty,&Float:tz,Float:offset_x=0.0,Float:offset_y=0.0,Float:offset_z=0.0);

 VehicleCollision Functions:

 IsVehicleCollisionEnabled();

 Tryg3D::InitVehicleCollision(); //OnGameModeInit / OnFilterScriptInit

 Tryg3D::ExitVehicleCollision();

 Tryg3D::SyncVehicleCollision(vehicleid); //EVF -> OnVehicleCreated

 IsToggledVehicleCollision(vehicleid);

 ToggleVehicleCollision(vehicleid,bool:toggle);

 PlayerCollision Functions:

 IsPlayerCollisionEnabled();

 Tryg3D::InitPlayerCollision(); //OnGameModeInit / OnFilterScriptInit

 Tryg3D::ExitPlayerCollision();

 Tryg3D::SyncPlayerCollision(playerid); //auto called after player spawn

 IsToggledPlayerCollision(playerid);

 TogglePlayerCollision(playerid,bool:toggle);

 ActorCollision Functions:

 IsActorCollisionEnabled();

 Tryg3D::InitActorCollision(); //OnGameModeInit / OnFilterScriptInit

 Tryg3D::ExitActorCollision();

 Tryg3D::SyncActorCollision(actorid); //After create/change actor position

 IsToggledActorCollision(actorid);

 ToggleActorCollision(actorid,bool:toggle);

 Extended Functions:

 randomex(min,max);

 Tryg3D::GetErrorCount();

 Tryg3D::ResetErrorCount();

 Tryg3D::SetStreamDistance(Float:streamdistance); //default 300.0

 Tryg3D::GetStreamDistance();

 Tryg3D::GetActiveCount();

 Tryg3D::GetVersion(value);

 Tryg3D::KeyPressed(key);

 Tryg3D::KeyReleased(key);

 Tryg3D::KeyHolding(key);

 Tryg3D::SecToTimeDay(second);      //Use: %d:%02d:%02d:%02d

 Tryg3D::MSToTimeDay(millisecond);  //Use: %d:%02d:%02d:%02d

 Tryg3D::SecToTime(second);         //Use: %02d:%02d:%02d

 Tryg3D::MSToTime(millisecond);     //Use: %02d:%02d:%02d

 Tryg3D::SecToTimeMini(second);     //Use: %02d:%02d

 Tryg3D::MSToTimeMini(millisecond); //Use: %02d:%02d

 Animation Functions:

 Animation::IsPlayerSkydiving(playerid);

 Animation::IsPlayerUsingParachute(playerid);

 Animation::IsPlayerAiming(playerid);

 Animation::IsPlayerStay(playerid);

 Animation::IsPlayerRunning(playerid);

 Animation::IsPlayerSwim(playerid);

 Animation::IsPlayerJump(playerid);

 Animation::IsPlayerParaFall(playerid);

 Animation::IsPlayerParaGlide(playerid);

 Animation::IsPlayerFall(playerid);

 Streamer Functions:

 SetPlayerAbsolutePosition(playerid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);

 SetPlayerAbsolutePositionVeh(playerid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);

 IsDynamicActorInRangeOfPoint(actorid,Float:range,Float:x,Float:y,Float:z);

 IsVehicleFullyInDynamicArea(vehicleid,areaid);

 Random::PointInDynamicArea(STREAMER_TAG_AREA:areaid,&Float:tx,&Float:ty,&Float:tz);

 IPL_CreateDynamicObject(modelid,Float:x,Float:y,Float:z,Float:qx,Float:qy,Float:qz,Float:qw,worldid=-1,interiorid=-1,playerid=-1,Float:streamdistance=STREAMER_OBJECT_SD,Float:drawdistance=STREAMER_OBJECT_DD,STREAMER_TAG_AREA:areaid=STREAMER_TAG_AREA:-1,priority=0);

 ColAndreas Functions:

 MovePointCol(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z);

 MovePointColCutLine(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:x,&Float:y,&Float:z,Float:cut_size=0.0);

 MovePointColCutLineEx(Float:sX,Float:sY,Float:sZ,Float:eX,Float:eY,Float:eZ,&Float:x,&Float:y,&Float:z,Float:cut_size=0.0);

 GetPointInFront3DCol(Float:x,Float:y,Float:z,Float:rx,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 GetPointInFront3DColEx(Float:x,Float:y,Float:z,Float:rx,Float:ry,Float:rz,Float:radius,&Float:tx,&Float:ty,&Float:tz);

 Float:GetPointInFrontOfPlayerCol(playerid,&Float:tx,&Float:ty,Float:radius);

 Float:GetPointInFrontOfCamera2DCol(playerid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfCamera3DCol(playerid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 Float:GetPointInFrontOfVehicle2DCol(vehicleid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfVehicle3DCol(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 GetGroundRotation(Float:x,Float:y,Float:size,&Float:rx,&Float:ry);

 GetPointCollisionFlags(Float:x,Float:y,Float:z,interiorid=0);

 IsCollisionFlag(value,flag);

 UndergroundFindZ(Float:x,Float:y,&Float:z);

 InteriorFindZ(Float:px,Float:py,Float:pz,Float:size=2.0,&Float:z=0.0);

 IsPointInWater(Float:x,Float:y,Float:z=0.0);

 IsPointInUnderwater(Float:x,Float:y,Float:z);

 IsPointInUnderground(Float:x,Float:y,Float:z);

 IsPointInAir(Float:x,Float:y,Float:z,bool:interior=false,Float:max_distance=2.2);

 IsPointInGround(Float:x,Float:y,Float:z,bool:interior=false,Float:max_distance=2.2);

 IsBetweenPlayersIsWall(playerid,targetid);

 IsBetweenPlayerToPointIsWall(playerid,Float:x,Float:y,Float:z);

 GetPointInWallForPoint(Float:x,Float:y,Float:z,Float:radius,&Float:tx,&Float:ty,&Float:tz,Float:sector=90.0);

 SetPlayerCameraDirectionLookAt(playerid,Float:x,Float:y,Float:z,Float:distance = 5.0,Float:rx=20.0,Float:sector=90.0);

 GetWallRotation(Float:sx,Float:sy,Float:sz,Float:ex,Float:ey,Float:ez,&Float:rx,&Float:rz,&Float:px=0.0,&Float:py=0.0,&Float:pz=0.0,Float:size=1.0,Float:cut_size=0.0);

 ColAndreas::FindGroundZ(Float:x,Float:y,Float:z,&Float:gZ);

 Tryg3D::CollisionCheck(Float:StartX,Float:StartY,Float:StartZ,Float:EndX,Float:EndY,Float:EndZ,&Float:x,&Float:y,&Float:z,&Item3D_Type:item_type=Item3D_Type:0,&element_id=0,Float:cut_size=0.0,ignore_vehicle = INVALID_VEHICLE_ID,ignore_player = INVALID_PLAYER_ID,ignore_actor = INVALID_ACTOR_ID,collision_flags = TRYG3D_COLLISION_FLAG_ALL);

 ColAndreas Extended Functions:

 Tryg3D::IsColAndreasInit();

 Tryg3D::SafeColAndreasInit();

 ColAndreas Callbacks:

 OnColAndreasRemoveBuilding();

 Grenade Detection Callbacks (ColAndreas):

 OnPlayerDroppingGrenade(playerid,weaponid,Float:x,Float:y,Float:z);

 YSF Functions:

 Float:GetPlayerHydraReactorRX(playerid);

 IsPlayerHydraReactorBoost(playerid);

 GetPlayerRotation(playerid,&Float:rx,&Float:ry,&Float:rz);

 CountTextDraw();

 CountPlayerTextDraw(playerid);

 CountVisibleTextDraw(playerid);

 CountVisiblePlayerTextDraw(playerid);

 CountGangZone();

 CountVisibleGangZone(playerid);

 CountPlayerGangZone(playerid);

 CountVisiblePlayerGangZone(playerid);

 IsVehicleOnSpawn(vehicleid,Float:check_radius=1.0);

 IsPlayerOnSpawn(playerid,Float:check_radius=1.0);

 Random::PointInGangZone(zoneid,&Float:tx,&Float:ty);

 Random::PointInPlayerGangZone(playerid,zoneid,&Float:tx,&Float:ty);

 FCNPC Functions:

 FCNPC::GetPointInFront(npcid,&Float:tx,&Float:ty,Float:radius);

 FCNPC::InRangeOfPoint(npcid,Float:range,Float:x,Float:y,Float:z);

 FCNPC::GetTargetAngle(npcid,Float:x,Float:y,&Float:rz=0.0);

 FCNPC::SetTargetAngle(npcid,Float:x,Float:y,&Float:rz=0.0);

 FCNPC::SetVehicleRotation(npcid,Float:rx,Float:ry,Float:rz);

 FCNPC::SetVehicleTargetRotation(npcid,Float:tx,Float:ty,Float:tz,Float:ry=0.0);

 FCNPC::GoToAir(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,Float:min_distance=0.0,stopdelay=250);

 FCNPC Functions (ColAndreas):

 FCNPC::GetPointInFrontCol(npcid,&Float:tx,&Float:ty,Float:radius);

 FCNPC::GoToCol(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=0.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);

 FCNPC::GoToPlayerCol(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=0.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);

 FCNPC::GoToPlayerOnGroundCol(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=1.0,Float:climbing=2.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);

 FCNPC::GoToPlayerOnGroundColVeh(npcid,playerid,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,Float:cut_size=1.0,Float:climbing=2.0,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);

 FCNPC::GoToAirCol(npcid,Float:x,Float:y,Float:z,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,Float:cut_size=0.0,Float:min_distance=0.0,stopdelay=250);

 FCNPC::RandomMoveInDynamicArea(npcid,STREAMER_TAG_AREA:areaid,Float:climbing=2.0,type=FCNPC_MOVE_TYPE_AUTO,Float:speed=FCNPC_MOVE_SPEED_AUTO,mode = FCNPC_MOVE_MODE_AUTO,bool:set_angle=true,Float:min_distance=0.0,stopdelay=250);

 FCNPC::SetAbsolutePosition(npcid,Float:x,Float:y,Float:z,Float:angle,worldid=-1,interiorid=-1,compensatedtime=-1,freezeplayer=1);

 FCNPC::SetFloorPos(npcid);

 VehicleStreamer Functions:

 GetDynamicVehicleFlags(vehicleid);

 Float:GetDynamicVehicleSpeed(vehicleid);

 Float:GetPointInFrontOfDynVeh2D(vehicleid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfDynVeh3D(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 IsDynVehInRangeOfPoint(vehicleid,Float:range,Float:x,Float:y,Float:z);

 IsDynVehFullyInDynamicArea(vehicleid,areaid);

 Float:GetPointInFrontOfDynVeh2DCol(vehicleid,&Float:tx,&Float:ty,Float:radius);

 GetPointInFrontOfDynVeh3DCol(vehicleid,&Float:tx,&Float:ty,&Float:tz,Float:radius,&Float:rx=0.0,&Float:rz=0.0);

 IsDynamicVehicleOnSpawn(vehicleid,Float:check_radius=1.0);

 GetDynamicVehicleRotation(vehicleid,&Float:rx,&Float:ry,&Float:rz);

 Deprecated Functions:

 GetDistanceBetweenPoints       -> GetDistanceBetweenPoints3D

 GetPlayersDistance             -> Item::GetDistance

 GetVehiclesDistance            -> Item::GetDistance

 GetObjectsDistance             -> Item::GetDistance

 GetActorDistanceFromPoint      -> Item::GetDistanceFromPoint

 GetDistanceBetweenPlayers      -> Item::GetDistance

 GetDistanceBetweenVehicles     -> Item::GetDistance

 GetDistanceBetweenObjects      -> Item::GetDistance

 GetPlayerActorDistance         -> Item::GetDistance

 GetPlayerVehicleDistance       -> Item::GetDistance

 GetPlayerObjectDistance        -> Item::GetDistance

 IsPlayerInCircle               -> Item::In...

 IsPlayerInSphere               -> Item::In...

 IsPlayerInRectangle            -> Item::In...

 IsPlayerInCube                 -> Item::In...

 IsPlayerInPolygon              -> Item::In...

 GetPlayerCollisionFlags        -> Item::GetCollisionFlags

 GetVehicleCollisionFlags       -> Item::GetCollisionFlags

 IsPointInWaterFrontOfPlayer    -> Item::IsPointInWaterOrient

 MovePointColWithVehicle        -> Tryg3D::CollisionCheck

 MovePointColWithVehicleCut     -> Tryg3D::CollisionCheck

 Item::ToPointIsVeh             -> Item::CollisionToPoint

 Item::ToItemIsVeh              -> Item::CollisionToItem

 Symbols:

 FLOAT_PI                       - pi constant value

 FLOAT_EULER                    - Euler number

 FLOAT_NAN                      - Float NaN

 FLOAT_DEFECT                   - Float defect (Arc Test)

 FLOAT_INFINITY                 - Float Infinity

 VBTP                           - Value Bigger Than Possible

 VLTP                           - Value Lower Than Possible

 Definitions:                   

 VERTICAL_CAMERA_RADIUS         - (modifiable)

 HORIZONTAL_CAMERA_RADIUS       - (modifiable)

 INVALID_ROTATION               - (modifiable)

 MAX_POLYGON_POINTS             - (modifiable)

 VEHICLE_SPEED_MULTIPLIER       - (modifiable)

 PLAYER_SPEED_MULTIPLIER        - (modifiable)

 INVALID_MOVE_TIME              - (modifiable)

 INVALID_MOVE_SPEED             - (modifiable)

 INVALID_VIRTUAL_WORLD          - (modifiable)

 CHARACTER_GROUND_Z_DIFF        - (modifiable)

 TRYG3D_MAX_AREA_CHECK          - Define area check limit when using Vehicle/Player/Actor collision system (modifiable)

 TRYG3D_RANDOM_MAX_ANGLE

 WEAPON_DYNAMIC_EXPLOSION_DMG   - deatch reason by using Cast3D::ExplosionDMG

 WEAPON_DYNAMIC_EXPLOSION_RANGE - deatch reason by using Cast3D::ExplosionRangeDMG

 Position Flags:

 POSITION_FLAG_WORLD

 POSITION_FLAG_INTERIOR

 POSITION_FLAG_AIR

 POSITION_FLAG_GROUND

 POSITION_FLAG_WATER

 POSITION_FLAG_UNDERWATER

 POSITION_FLAG_UNDERGROUND

 Tryg3D::CollisionCheck Flags:

 TRYG3D_COLLISION_FLAG_NONE

 TRYG3D_COLLISION_FLAG_OBJECT

 TRYG3D_COLLISION_FLAG_VEHICLE

 TRYG3D_COLLISION_FLAG_PLAYER

 TRYG3D_COLLISION_FLAG_ACTOR

 TRYG3D_COLLISION_FLAG_ALL

 Vehicle Flags:

 VF_STREET        VF_AIRBORNE      VF_NATATORIAL    VF_MILITARY      VF_TRAIN         VF_RC            VF_CARRIAGE

 VF_AIRPLANE      VF_HELICOPTER    VF_BIKES         VF_TRAILER       VF_TOWABLE       VF_POLICE

 Vehicle Parts:

 VEHICLE_PART_RFTIRE         - Right Front tire

 VEHICLE_PART_LFTIRE         - Left Front tire

 VEHICLE_PART_RRTIRE         - Right Rear tire

 VEHICLE_PART_LRTIRE         - Left Rear tire

 VEHICLE_PART_HOOD           - In Front

 VEHICLE_PART_TRUNK          - Behind

 VEHICLE_PART_ROOF           - Roof

 VEHICLE_PART_CHASSIS        - Chassis

 VEHICLE_PART_PETROLCAP      - Petrolcap

 enum 'element_orientation'

 # o_left                    - Orientation Left

 # o_right                   - Orientation Right

 # o_up                      - Orientation Up

 # o_down                    - Orientation Down

 # o_front                   - Orientation Front

 # o_back                    - Orientation Back

 # o_front_left              - Orientation Front left (diagonal)

 # o_front_right             - Orientation Front right (diagonal)

 # o_back_left               - Orientation Back left (diagonal)

 # o_back_right              - Orientation Back right (diagonal)

 enum 'Item3D_Type'

 # item_player

 # item_npc

 # item_actor

 # item_object

 # item_vehicle

 # item_dynamic_object

 # item_dynamic_pickup

 # item_dynamic_cp

 # item_dynamic_racecp

 # item_dynamic_mapicon

 # item_dynamic_3dtext

 # item_dynamic_actor

 # item_dynamic_vehicle

 # item_fcnpc

 enum 'StreamType'

 # s_invalid

 # s_circle

 # s_cylinder2d

 # s_cylinder3d

 # s_sphere

 # s_rectangle

 # s_cube2d

 # s_cube3d

 # s_polygon

 # s_circularsector

 # s_sphericalsector

 # s_cone2d

 # s_cone3d

 # s_ellipse

 # s_ellipticalcyl2d

 # a_sphericalsectorex

 enum 'Vectors3D'

 # Float: T3D:X             - Position X

 # Float: T3D:Y             - Position Y

 # Float: T3D:Z             - Position Z

 # Float: T3D:A             - Angle

 enum 'Float3D'

 # Float: T3D:X             - Position X

 # Float: T3D:Y             - Position Y

 # Float: T3D:Z             - Position Z

 # Float: T3D:rX            - Rotation X

 # Float: T3D:rY            - Rotation Y

 # Float: T3D:rZ            - Rotation Z

 # Float: T3D:tX            - Target Position X

 # Float: T3D:tY            - Target Position Y

 # Float: T3D:tZ            - Target Position Z

 #        T3D:VW            - Virtual World ID

 #        T3D:INT           - Interior ID

 # Float: T3D:SPEED         - Speed

 enum 'LongFloat3D'

 # Float: T3D:X             - Position X

 # Float: T3D:Y             - Position Y

 # Float: T3D:Z             - Position Z

 # Float: T3D:rX            - Rotation X

 # Float: T3D:rY            - Rotation Y

 # Float: T3D:rZ            - Rotation Z

 # Float: T3D:tX            - Target Position X

 # Float: T3D:tY            - Target Position Y

 # Float: T3D:tZ            - Target Position Z

 # Float: T3D:trX           - Target Rotation X

 # Float: T3D:trY           - Target Rotation Y

 # Float: T3D:trZ           - Target Rotation Z

 # Float: T3D:VecX          - Vector Position X

 # Float: T3D:VecY          - Vector Position Y

 # Float: T3D:VecZ          - Vector Position Z

 #        T3D:VW            - Virtual World ID

 #        T3D:INT           - Interior ID

 # Float: T3D:SPEED         - Speed

 enum 'OrientationCube3D'

 # o_left_back_down

 # o_right_back_down

 # o_right_front_down

 # o_left_front_down

 # o_left_back_up

 # o_right_back_up

 # o_right_front_up

 # o_left_front_up

 enum 'T3D:eulermode'

 # T3D:euler_xzx - Proper / Classic Euler angles

 # T3D:euler_xyx - Proper / Classic Euler angles

 # T3D:euler_yxy - Proper / Classic Euler angles

 # T3D:euler_yzy - Proper / Classic Euler angles

 # T3D:euler_zyz - Proper / Classic Euler angles

 # T3D:euler_zxz - Proper / Classic Euler angles

 # T3D:euler_xzy - Tait-Bryan angles

 # T3D:euler_xyz - Tait-Bryan angles

 # T3D:euler_yxz - Tait-Bryan angles

 # T3D:euler_yzx - Tait-Bryan angles

 # T3D:euler_zyx - pitch roll yaw

 # T3D:euler_zxy - sa-mp

Download:
3DTryg.inc

More functions available with plugins:
ColAndreas (Recommended 1GB RAM for server by using this plugin)
YSF
Streamer
FCNPC
VehicleStreamer

Compatibility includes:
rotation.inc by Nero_3D
i_quat.inc by IllidanS4
YSI Libraries (with #define ENABLE_3D_TRYG_YSI_SUPPORT if you got error)

Supported elements:
1. Character Elements:
- Player's
- NPC's
- Actor's
- FCNPC's

2. Static Elements:
- Object's
- Vehicle's
- GangZone's

3. Dynamic Elements:
- DynamicObject's
- DynamicPickup's
- DynamicCP's
- DynamicRaceCP's
- DynamicMapIcon's
- Dynamic3DText's
- DynamicActor's
- DynamicVehicles's

4. Areas 2D / 3D:
a) Geometric Figures:
- Circle
- Rectangle
- Polygon
- CircularSector
- Ellipse
- Cone2D

b) Chunk:
- Cylinder2D
- Sphere
- Cube
- EllipticalCylinder2D

c) Rotated Chunk:
- Cylinder3D
- SphericalSector
- Cube3D
- Cone3D