EnWorld.c

Go to the documentation of this file.

 
//----------------------------------------------
typedef int[] WorldHandle;
 
proto native float GetWorldTime();
 
proto native WorldHandle SetCurrentWorld(WorldHandle world);
 
//proto native void SchedulePreload(vector pos, float radius);
 
proto native IEntity FindEntityByName(IEntity worldEnt, string name);
proto native IEntity FindEntityByID(IEntity worldEnt, int ID);
 
proto native int GetNumActiveEntities(IEntity worldEntity);
proto native IEntity GetActiveEntity(IEntity worldEntity, int index);
 
//----------------------------------------------
enum CameraType
{
  PERSPECTIVE,
  ORTHOGRAPHIC
};
 
proto native void SetListenerCamera(int camera);
 
proto native void SetCamera(int cam, vector origin, vector angle);
 
proto native void SetCameraEx(int cam, const vector mat[4]);
 
proto native void GetCamera(int cam, out vector mat[4]);
 
proto native void SetCameraVerticalFOV(int cam, float fovy);
proto native void SetCameraFarPlane(int cam, float farplane); //default 160000 units
proto native void SetCameraNearPlane(int cam, float nearplane); //default 5 units
 
proto native void SetCameraType(int cam, CameraType type);
 
enum PostProcessEffectType
{
  None,
  UnderWater,
  SSAO,
  DepthOfField,
  HBAO,
  RotBlur,
  GodRays,
  Rain,
  FilmGrain,
  RadialBlur,
  ChromAber,
  WetDistort,
  DynamicBlur,
  ColorGrading,
  Colors,
  Glow,
  SMAA,
  FXAA,
  Median,//unused?
  SunMask,
  GaussFilter,
  SSR //not available
};
proto native void SetCameraPostProcessEffect(int cam, int priority, PostProcessEffectType type, string materialPath);
 
//ent can be NULL for world-space coords
proto vector ProjectVector(int cam, IEntity ent, vector vec);
proto vector UnprojectVector(int cam, float x, float y, vector dir);
 
 
//----------------------------------------------
 
typedef int[] HLIGHT;
 
enum LightType
{
  POINT, //< point light, all directional light
  SPOT, //< spot light, direction is determined by owner (entity)
  DIRECTIONAL,
  AMBIENT
};
 
enum LightFlags
{
  DYNAMIC,
  CASTSHADOW,
  CHEAP
};
 
proto HLIGHT AddLight(IEntity owner, LightType type, LightFlags flags, float radius, vector color);
proto native bool RemoveLight(HLIGHT light);
proto native bool SetLightEx(HLIGHT light, float radius, vector color);
proto native bool SetLightTexture(HLIGHT light, string cubemap);
proto native int SetLightFlags(HLIGHT light, LightFlags flags);
proto native int ClearLightFlags(HLIGHT light, LightFlags flags);
proto native bool SetLightCone(HLIGHT light, float cone);
 
proto native float GetSceneHDRMul(int camera);
 
 
//----------------------------------------------
enum TraceFlags
{
  BONES, //< tests collision geometries around bones of animated objects
  ENTS, //< tests entities
  WORLD, //< tests world bounding box
  ONLY_PHYSICS,
  WATER, //< tests collision with water surface
  PASSTRANSLUCENT,//< Do not intersects with entities with EntityFlags.TRANSLUCENT set
  RAGDOLLS, //< tests ragdolls
  VISTEST, //< performs visibility test first. Not necessary for entities receiving EntityEvent.VISIBLE, because there is a certainty that a camera will see them
  NOTRACE,
  TRANSPARENT_OCCLUDERS
};
 
enum TraceShape
{
  LINE,
  BOX,
  OBB,
  SPHERE
};
 
class TraceContact
{
  float Fraction;
  int Content;
  int Surfparm;
  int MaterialFlags;
  int Triangle;
  int SurfaceID;
  owned string MaterialName;
  owned string OriginalMaterialName;
  float Plane[4];
  vector Point;
}
 
proto native bool TraceLineToEntity(IEntity ent, vector start, vector end, out TraceContact contact);
 
//bool FilterCallback(Class target [, vector rayorigin, vector raydirection])
 
class TraceParam: Managed
{
  vector Start;
  vector End;
  int LayerMask = 0xffffffff;
  TraceFlags Flags;
  IEntity Exclude;
 
};
 
class TraceSphere: TraceParam
{
  float Radius;
};
 
class TraceBox: TraceParam
{
  vector Mins;
  vector Maxs;
};
 
class TraceOBB: TraceBox
{
  vector Mat[3];
};
 
proto volatile float TraceMove(TraceParam param, out IEntity cent, out float plane[4], out int surfparm, func filtercallback);
 
 
proto native int P2PVisibilityEx(vector from, vector to, int flags);
 
proto int SphereQuery(vector origin, float radius, out IEntity visents[], int ents, int fmask);
 
proto native bool IsBoxVisible(vector mins, vector maxs, int flags);
 
proto int VisEntities(vector origin, vector look, float angle, float radius, out IEntity ents[2], int maxents, int fmask);
 
class OcclusionQuery
{
  proto private void ~OcclusionQuery();
 
  proto native int GetResult();
 
  proto native void SetPosition(vector pos);
  proto native void Destroy();
};
 
 
//----------------------------------------------
typedef int[] hDecal;
 
proto native hDecal CreateDecal(IEntity entity, vector origin, vector project, float nearclip, float angle, float size, string materialName, float lifetime, int flags);
 
proto native void RemoveDecal(hDecal decal);
 
proto native hDecal CreateLandMarkDecal(IEntity entity, vector origin, vector normal, float edgeSize, float lifeTime, string materialName, hDecal prevDecal, float alpha);
 
 
proto native int CanAddToLandMarkDecal(hDecal lmDecal, IEntity entity, string mat, vector newPoint);
 
proto native bool AddPointToLandMarkDecal(hDecal lmDecal, vector point, vector normal, float alpha);
 
proto native void FinalizeLandMarkDecal(hDecal lmDecal, bool addAlpha, float alphaDist);
 
proto native bool IsLandMarkFinalized(hDecal lmDecal);
 
proto native vector GetLastLandMarkPoint(hDecal lmDecal);
 
proto native void SetGlobalLandMarkParams(float minSegmentLength, float maxSegmentLength, float degAngle);
 
 
 
 
//----------------------------------------------
proto native bool IsOcean();
 
proto native float GetOceanHeight(float worldX, float worldZ);
 
 
proto native vector GetOceanHeightAndDisplace(float worldX, float worldZ);