proto.c

Go to the documentation of this file.

 
/*
  Function/method modifiers:
  proto - prototyping of internal function (C++ side)
  native - native call convention of internal function (C++ side)
  volatile - internal function that may call back to script (hint for
  compiler that context need to be saved on stack)
  private - function may not be called from script
  event - hint for tools that the function should be exposed as
  Entity script event.
 
  Variable modifiers:
  owned - modifier for returing internal functions. Tells to script-VM,
  that returning variable (string or array) must not be released
  out - modifier for function parameters. It tells that variable will
  be changed by function call (used mainly by internal functions)
  inout - modifier for function parameters. It tells that variable will
  be used and then changed by function call (used mainly by internal functions)
 
  const - constants. May not be modified.
  reference - hint for tools (Material editor), that the variable may be used
  as parameter in material
*/
 
 
/*===================================================================*/
/*              Enforce engine API             */
/*===================================================================*/
 
//placeholder
class AnimEvent
{
  int type;
  int slot;
};
 
class SoundEvent
{
  int type;
  int handle;
};
 
 
typedef int[] vobject;
 
class vobject
{
  proto native IEntitySource ToEntitySource();
}
 
#ifdef ENF_DONE
 
  //------------------------------------------
  // SOUND API
  //------------------------------------------
  //TODO:
  typedef int[] HSOUND;
 
  //flags
  //SFX_ONCE
  //SFX_MUSIC
  //SFX_AMBIENT
  //SFX_3D
  //SFX_DISCARDABLE
  //SFX_DIRECTIONAL
  //SFX_DOPPLER
  //SFX_STATIC
  //SFX_NOTEST
 
  //proto volatile HSOUND PlaySound(int soundScene, IEntity source, string sshader, int flags);
  proto volatile native void EndSound(HSOUND snd);
 
  //volume 0...1. Logaritmic scale
  proto native int SetSoundVolume(HSOUND sound, float volume)
  proto native int SetSoundFrequency(HSOUND sound, int freq)
 
 
  //returns 0, if soundid is not valid
  proto native int GetSoundLength(HSOUND sound)
 
  //returns -1, if soundid is not valid
  proto native int GetSoundPosition(HSOUND sound)
 
  //defaultne se pouziva EAX prostredi nadefinovane v mape, ale lze ho prebit touto fci.
  // Mohou se michat dve ruzna prostredi v pomeru danem hodnotou fade (fade==0 -> 100% env1, fade==1 -> 100% env2).
  //pokud chceme michat aktualni prostredi s nejakym jinym, lze pouzit zastupny nazev "$current".
  //Tim lze dosahnout nafadovani vlastniho prostredi, kdyz fci postupne volame napr. takto:
  //SetEAXEnvironment("$current", "Drugged", fade)
  //pricemz hodnota fade postupne narusta od nuly do jedne
  //proto native bool SetEAXEnvironment(string env1, string env2, float fade)
#endif
 
class PacketOutputAdapter
{
  proto native void WriteBool(bool value); //size: 1 byte
  proto native void WriteInt(int value); //size: 4 bytes
  proto native void WriteFloat(float value); //size: 4 bytes
  proto native void WriteString(string value); //size: n bytes (string length)
  proto native void WriteVector(vector value); //size: 12 bytes
  proto native void WriteMatrixAsQuaternionVector(vector mat[4]); //size: 28 bytes
  proto native void WriteIntAsByte(int value); //write int in range <-128, 127>      size: 1 byte
  proto native void WriteIntAsUByte(int value); //write int in range <0, 255>       size: 1 byte
  proto native void WriteIntAsHalf(int value); //write int in range <-32768, 32768>  size: 2 bytes
  proto native void WriteIntAsUHalf(int value); //write int in range <0, 65535>     size: 2 bytes
  proto native void WriteFloatAsByte(float value, float min, float max); // size: 1 byte
  proto native void WriteFloatAsHalf(float value, float min, float max); // size: 2 bytes
};
 
class PacketInputAdapter
{
  proto native bool ReadBool();
  proto native int ReadInt();
  proto native float ReadFloat();
  proto string ReadString();
  proto native vector ReadVector();
  proto void ReadMatrixAsQuaternionVector(vector mat[4]);
  proto native int ReadIntAsByte();
  proto native int ReadIntAsUByte();
  proto native int ReadIntAsHalf();
  proto native int ReadIntAsUHalf();
  proto native float ReadFloatAsByte(float min, float max);
  proto native float ReadFloatAsHalf(float min, float max);
};
 
proto native void MakeScreenshot(string name);
 
proto native int GetFPS();
 
//----------------------------------------------
 
proto native int LoadSkyPresets(string presetsFile);
 
proto native int InitSky(string presetName);
 
proto native int SetSkyPreset(string presetName, float stormy, float dayTime);
 
proto native int LerpSkyPreset(string presetName1, string presetName2, float dayTime, float stormy1, float stormy2, float lerpVal);
 
proto native int LerpSkyPreset3(string presetName1, string presetName2, string presetName3, float dayTime, float stormy1, float stormy2, float stormy3, float w1, float w2, float w3);
 
proto native void SetSkyUserPlanets(bool enabled);
 
proto native bool SetSkyPlanet(int index, float azimuthDeg, float zenithDeg);
 
proto native bool SetSkyPlanetSize(int index, float angleDeg);
 
proto native void SetStarsObserverTime(int year, int month, int day, int hour, int minute, float sec, int offsetSec);
 
proto native void SetStarsObserverPosition(float latitudeDeg, float longitudeDeg);
 
proto native void SetRealStarAutoUpdate(bool update);
 
 
proto native void SetNightLayerRotMatrix(vector mat[3]);
 
proto native void SetStarsRotMatrix(vector mat[3]);
 
 
//----------------------------------------------
typedef int[] Material;
 
class Material
{
  proto bool SetParam(string propertyName, void value);
 
  proto native void ResetParam(string propertyName);
 
  proto native int GetParamIndex(string paramName);
 
  proto void SetParamByIndex(int paramIndex, void value);
};
 
int VectortoRGBA(vector vec, float h)
{
  float x, y, z;
  int r, g, b, a, rgba;
 
  x = vec[0];
  y = vec[1];
  z = vec[2];
 
  x = x * 127.0 + 128.0;
  y = y * 127.0 + 128.0;
  z = z * 127.0 + 128.0;
  h = h * 255.0;
 
  a = (int)h << 24;
  r = (int)x << 16;
  g = (int)y << 8;
  b = z;
 
  return r | g | b | a;
}
 
 
//-----------------------------------------------------------------
int ARGB(int a, int r, int g, int b)
{
  a = a << 24;
  r = r << 16;
  g = g << 8;
  return a | r | g | b;
}
 
//-----------------------------------------------------------------
int ARGBF(float fa, float fr, float fg, float fb)
{
  return ARGB((float)(fa * 255.0), (float)(fr * 255.0), (float)(fg * 255.0), (float)(fb * 255.0));
}
 
//-----------------------------------------------------------------
int AWHITE(int a)
{
  return a << 24 | 0xffffff;
}
 
//-----------------------------------------------------------------
int LerpARGB(int c1, int c2)
{
  int cb1, cb2;
  const int cmask = 0x00ff00ff;
 
  cb1 = c1 >> 8 & cmask;
  cb2 = c2 >> 8 & cmask;
  cb1 = cb1 + cb2 >> 1;
 
  c1 = c1 & cmask;
  c2 = c2 & cmask;
  c1 = c1 + c2 >> 1;
 
  return cb1 << 8 | c1;
}
 
//-------------------------------------------------------------------------
class Link<Class T>
{
  proto private native void Init(T init);
  proto private native Object Get();
 
  void Release()
  {
    T obj = Get();
    if (obj)
      obj.Release();
  }
  void Link(T init)
  {
    Init(init);
  }
 
  T Ptr()
  {
    return Get();
  }
 
  bool IsNull()
  {
    if (!Get())
      return true;
 
    return false;
  }
};