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);