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