diff options
Diffstat (limited to 'doc')
| -rw-r--r-- | doc/SMELTdoc | 837 |
1 files changed, 837 insertions, 0 deletions
diff --git a/doc/SMELTdoc b/doc/SMELTdoc new file mode 100644 index 0000000..2f6bdd2 --- /dev/null +++ b/doc/SMELTdoc @@ -0,0 +1,837 @@ +A simple SMELT documentation for SMELT developers (myself) ... +API Level 3 + +Types========================================================================== +DWORD: ranged 0~4294967296 (32 bit unsigned int) +WORD: ranged 0~65536 (16 bit unsigned int) +BYTE: ranged 0~256 (8 bit unsigned int) +smHook: bool() call backs +SMCHN: Channel handle. Generated when a effect was played. +SMSFX: Sound FX handle. +SMTEX: Texture handle. +SMTRG: Render Target handle. Targets provide render to texture support. + +Macros========================================================================= +ARGB(a,r,g,b): Generates a hardware color with the specificed values. +RGBA(r,g,b,a): Same as ARGB, with different parameter order. +GET<A|R|G|B>(col): Extract alpha/red/green/blue value from a hardware color. +SET<A|R|G|B>(col,a|r|g|b): Set alpha/red/green/blue value of a hardware color. + +PI: 3.14159265358979323846f + +BLEND_ALPHAADD/BLEND_ALPHABLEND: Alpha blending methods. +BLEND_COLORADD/BLEND_COLORMUL/BLEND_COLORINV: Color blending methods. +BLEND_ZWRITE/BLEND_NOZWRITE: Depth blending methods. +The BLEND_* macros of the different types can be or'd together. + +FPS_FREE/FPS_VSYNC: Special fps values. + +INPUT_*: Input event types. + +PRIM_*: Primitive types. + +SMELT_APILEVEL: SMELT api version. + +SMINP_*: Key modifiers. They can be or'd together. +SMKST_*: Key states. +SMK_*: Keys. + +Sturctures===================================================================== +smInpEvent: Input event structure. +-chcode: Char code. +-sccode: Key scan code. +-type: Input event type. The macros INPUT_* are used. +-flag: Modifiers. The macros SMINP_* are used. +-wheel: Wheel motion. +-x,y: Mouse position. + +smVertex: Vertex structure. +-x,y,z: Position. Z can be used for depth testing in 2D mode. +-col: Vertex color. +-tx,ty: Texture coordinates. + +smTriangle: Triangle primitive structure. +-v[3]: Vertexes of the triangle. +-tex: Texture of the triangle. +-blend: Blend mode of the triangle. The macros BLEND_* are used. + +smQuad: Quadrilateral primitive structure. +-v[4]: Vertexes of the quadrilateral. +-tex: Texture of the quadrilateral. +-blend: Blend mode of the quadrilateral. The macros BLEND_* are used. +WARNING: Quadrilaterals are treated as two triangles internally. +You may get unwanted results if the quadrilateral is not a parallelogram. + +smTexRect: Texture rectangle sturcture. +-x,y: Top left coordinate of the texture used. +-w,h: Width & height of the texture used. + +Exposed function=============================================================== +SMELT* smGetInterface(int apilevel) +Returns an interface to the SMELT core functions if the apilevel matches the +internal one, otherwise it returns NULL. + +Packaged SMELT core functions================================================== +All these functions are packaged in the class "SMELT". + +void smRelease() [core] +Release one reference to the SMELT core. Once all references are released, +the core will commit suicide and all resources used by it will be freed. + +bool smInit() [core] +Initialize the SMELT interface, including the OpenGL/Direct3D interfaces, the +OpenAL interfaces and the input interfaces. Functions from these interfaces +won't function until smInit() is called. The application window will also +be created. +If the interfaces are initialized successfully, this function returns true, +otherwise it returns false. The errors are written to stderr and the log file +if set. + +void smFinale() [core] +Deinitialize the SMELT interface. This function closes the application window +and frees all resources managed by SMELT. + +void smMainLoop() [core] +Starts the main loop, which calls UpdateFunc/FocFunc/UnFocFunc/QuitFunc at +proper occasion. +This function requires the UpdateFunc set and the initialization of the SMELT +interface. + +void smUpdateFunc(smHook func) [core] +Sets the update function. +The update function returns bool and takes no parameters. +If the update function returns true, the main loop will break, otherwise +the main loop runs perpetually. +The update function is called every frame. + +void smUnFocFunc(smHook func) [core] +Sets the unfocus function. +The unfocus function is called when the application window loses focus. + +void smFocFunc(smHook func) [core] +Sets the focus function. +The focus functions is called when the application window gains focus. + +void smWinTitle(const char* title) [core] +Sets the application window title. +The default title is "untitled". + +bool smIsActive() [core] +Returns true if the application window has focus. + +void smNoSuspend(bool para) [core] +By default, the update function won't be called when the application +window doesn't have focus (para=false). +Call this with para=true to make SMELT behave differently. + +void smVidMode(int resX,int resY,bool _windowed) [core] +Sets the application video mode. +The default mode is 800 x 600 fullscreen. +Inappropriate values may cause the failure of smInit(). +In addition, only the _windowed parameter can be changed on-the-fly. + +void smLogFile(const char* path) [core] +Sets the log file path. + +void smLog(const char* format,...) [core] +Write something to the log file. +The C-style formatting can be used. +The log will be written to stderr and the log file if set. + +void smScreenShot(const char* path) [core] +Takes a shot of the application window content and saves it to the +given path. + + +void smSetFPS(int fps) [core/FPS] +Sets the desired FPS value. +The macros FPS_* can be used. + +float smGetFPS() [core/FPS] +Gets the current FPS value. +The current FPS value is updated every second. + +float smGetDelta() [core/FPS] +Gets the delta time between the current frame and the last frame. + +float smGetTime() [core/FPS] +Gets the time in milliseconds since the call to smInit(). + +SMSFX smSFXLoad(const char *path) [core/SFX] +Loads a sound file from the given path. Only ogg files are supported. + +SMSFX smSFXLoadFromMemory(const char *ptr,DWORD size) [core/SFX] +Loads a sound file from the given memory block. Only ogg files are supported. + +SMCHN smSFXPlay(SMSFX fx,int vol=100,int pan=0,float pitch=1.,bool loop=0) +[core/SFX] +Plays the given SFX. All parameters except the fx handle is optional. +A channel is generated and can be used to control the playing of the SFX. +The channel is valid until it stops. +Volume should be 0~100. +Panning should be -100~100. +The values would be clamped to the range given above. + +float smSFXGetLengthf(SMSFX fx) [core/SFX] +Gets the sound length in seconds. + +DWORD smSFXGetLengthd(SMSFX fx) [core/SFX] +Gets the sound length in samples. + +void smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r) [core/SFX] +Sets the loop point of a SFX. The loop points will be used when the fx is +played with loop=true. +The loop points are expressed in samples. +By default, the whole SFX is looped. +This function uses AL_SOFT_loop_points and may not work if SMELT isn't built +against OpenAl Soft. + +void smSFXFree(SMSFX fx) [core/SFX] +Releases the sound file from memory. +The handle will be invalid thereafter. + +void smChannelVol(SMCHN chn,int vol) [core/SFX] +Sets channel volume (0~100). + +void smChannelPan(SMCHN chn,int pan) [core/SFX] +Sets channel panning (-100~100). + +void smChannelPitch(SMCHN chn,float pitch) [core/SFX] +Sets channel pitch. + +void smChannelPause(SMCHN chn) [core/SFX] +Pauses the channel. + +void smChannelResume(SMCHN chn) [core/SFX] +Resumes the paused channel. + +void smChannelStop(SMCHN chn) [core/SFX] +Stops the channel. The channel handle will be invalid thereafter. + +void smChannelPauseAll() [core/SFX] +Pauses all playing channels. + +void smChannelResumeAll() [core/SFX] +Resumes all channels. + +void smChannelStopAll() [core/SFX] +Stops all channels. + +bool smChannelIsPlaying(SMCHN chn) [core/SFX] +Tests if a channel is playing. + +float smChannelGetPosf(SMCHN chn) [core/SFX] +Gets current position in second. + +void smChannelSetPosf(SMCHN chn,float pos) [core/SFX] +Sets current position in second. + +int smChannelGetPosd(SMCHN chn) [core/SFX] +Gets current position in sample. + +void smChannelSetPosd(SMCHN chn,int pos) [core/SFX] +Sets current position in sample. + +void smGetMouse2f(float *x,float *y) [core/input] +Gets mouse position (within the window). + +void smSetMouse2f(float x,float y) [core/input] +Sets mouse position (within the window). + +int smGetWheel() [core/input] +Gets mouse wheel motion since the last frame. + +bool smIsMouseOver() [core/input] +Tests if the cursor is inside the application window. + +int smGetKeyState(int key) [core/input] +Gets the state of the given key. The SMK_* macros can be used. +Mouse buttons are treated as keys. +The return values are one of the SMKST_* macros. + +SMKST_NONE: the key is not pressed and is not just released either. +SMKST_RELEASE: the key is not pressed but is just released. +SMKST_HIT: the key is pressed but it was not pressed in the last frame. +SMKST_KEEP: the key is pressed and held since the last frame or earlier. + +int smGetKey() [core/input] +Gets the key pressed last frame. +If multiple keys are pressed, the last pressed one counts. + +bool smGetInpEvent(smInpEvent *e) [core/input] +Gets a event from the input queue. +The input parameter will be set to point the event. +If there are no events in the input queue, this function will return false. + +bool smRenderBegin2D(bool ztest=0,SMTRG trg=0) [core/GFX] +Starts rendering a 2D scene. +Set ztest to true if you want to use the z coordinate to control overlapping. +Set trg to the desired rendering target to render everything to the target. +The function resets the camera. You should setup the camera every frame. +NOTE: Any rendering function is not functional outside the smRenderBegin*D +function and its corresponding smRenderEnd function. + +bool smRenderBegin3D(float fov,SMTRG trg=0) [core/GFX] +Starts rendering a 3D scene. +Ztest is forced on in 3D mode. +Set trg to the desired rendering target to render everything to the target. +The projection matrix always has the near clipping value 0.1 and the far +clipping value 1000. +The function resets the camera. You should setup the camera every frame. +NOTE: Any rendering function is not functional outside the smRenderBegin*D +function and its corresponding smRenderEnd function. + +bool smRenderEnd() [core/GFX] +Ends rendering the scene. +NOTE: Any rendering function is not functional outside the smRenderBegin*D +function and its corresponding smRenderEnd function. + +void sm3DCamera6f2v(float *pos,float *rot) [core/GFX/Rendering] +Sets the 3D camera position and panning. +Each float vector should countain three elements. +The panning is Euler rotation (all in degrees). +If any of the vectors is NULL, the function will reset the camera. +The behaviour of the function is undefined in a 2D rendering session. + +void sm2DCamera5f3v(float *pos,float *dpos,float *rot) [core/GFX/Rendering] +Sets the 2D camera transformation. +pos should contain two elements describing the camera position. +dpos should countain two elements describing the rotation centre. +rot is the pointer to a single float describing the rotation (in degrees). +If any of the vectors is NULL, the function will reset the camera. +The behaviour of the function is undefined in a 3D rendering session. + +void smMultViewMatrix(float *mat) [core/GFX/Rendering] +Provides direct manipulation on the view matrix. You can use "look at" matrix +here, for example. +The matrix the same as the matrix defined in smMatrix, but stored in float. +(That's fairly stupid...) + +void smClrscr(DWORD color) [core/GFX/Rendering] +Clears the screen/rendering target with color. +Alpha channel is not applicable. + +void smRenderLinefd(float x1,float y1,float z1,float x2,float y2,float z2,DWORD +color) [core/GFX/Rendering] +Renders a line from (x1,y1,z1) to (x2,y2,z2) in the given color. +Lines have no textures. + +void smRenderLinefvd(float *p1,float *p2,DWORD color) [core/GFX/Rendering] +Renders a line from (p1[0],p1[1],p1[2]) to (p2[0],p2[1],p2[2]) in the given color. + +void smRenderTriangle(smTriangle *t) [core/GFX/Rendering] +Renders a triangle. + +void smRenderQuad(smQuad *q) [core/GFX/Rendering] +Renders a quadrilateral. + +smVertex* smGetVertArray() [core/GFX/Rendering] +Return a pointer to the internal vertex array for advanced batching. +The vertex array is rendered and cleared in this function. So you will always +get a full vertex array. +By default, the size of the vertex array is 4000. + +void smDrawVertArray(int prim,SMTEX texture,int blend,int _primcnt) +[core/GFX/Rendering] +Draws the vertex array modified by advanced batching. + +SMTRG smTargetCreate(int w,int h) [core/GFX] +Creates a rendering target (sized w*h). +Modern OpenGL supports non-power-of-two targets, however some of the D3D9 +hardwares doesn't. +The target will be automatically resized, larger than the requested size, if +it is not supported. + +SMTEX smTargetTexture(SMTRG targ) [core/GFX] +Gets the texture of the rendering target. + +void smTargetFree(SMTRG targ) [core/GFX] +Frees the rendering target. + +SMTEX smTextureCreate(int w,int h) [core/GFX] +Creates a blank texture (sized w*h). +OpenGL version supports non-power-of-two textures, however some of the D3D9 +hardwares doesn't. +The texture will be automatically resized, larger than the requested size, if +it is not supported. + +SMTEX smTextureLoad(const char *path,bool mipmap=false) [core/GFX] +Loads texture from the given file. +OpenGL version supports non-power-of-two textures, however some of the D3D9 +hardwares doesn't. +The texture will be automatically resized, larger than the requested size, if +it is not supported. +mipmapping doesn't work in OpenGL versions. + +SMTEX smTextureLoadFromMemory(const char *ptr,DWORD size,bool mipmap=false) +[core/GFX] +Loads texture from the given memory block. +OpenGL version supports non-power-of-two textures, however some of the D3D9 +hardwares doesn't. +The texture will be automatically resized, larger than the requested size, if +it is not supported. +mipmapping doesn't work in OpenGL versions. + +void smTextureFree(SMTEX tex) [core/GFX] +Release the texture from memory. + +int smTextureGetWidth(SMTEX tex,bool original=false) [core/GFX] +Gets the width of the texture. +If original==false and the texture is resized, the function will return the +resized p-o-t width of the texture. +Otherwise it returns the actual width of the texture file. + +int smTextureGetHeight(SMTEX tex,bool original=false) [core/GFX] +Gets the height of the texture. +If original==false and the texture is resized, the function will return the +resized p-o-t height of the texture. +Otherwise it returns the actual height of the texture file. + +DWORD* smTextureLock(SMTEX tex,int l,int t,int w,int h,bool ro=true) [core/GFX] +Locks the texture for reading/writing. +The locked area is defined as (l,t,w,h): left, top, width, height. +if ro==true, the changes won't be written back to the video memory. +Textures of rendering targets cannot be locked. + +void smTexutreUnlock(SMTEX tex) [core/GFX] +Unlocks the texture so that it can be used for rendering. +The changes will be commited to the video memory if ro==false when locking +the texture. + +SMELT extensions=============================================================== + +smAnimation==================================================================== +The extension provides texture management and animated entity support. + +Texture info class: smTexInfo +smTexRect rect; Texture rectangle +char *name,*path; name and internal path of the texture +SMTEX tex; Texture handle + +Animation info class: smAnmInfo +smTexInfo frames[256] Frames of the animation +int framedur[256] Frame durations +int mode loop mode: 0=noloop 1=loop 2=bidi loop +int fc Frame count +char* name Name of the animation + +Animation file class: smAnmFile +For the format of the .anm file, please refer to the file datapackFormat. +-bool loadAnmFromMemory(char* ptr,DWORD size) + Loads a .anm file from the given memory block. + .anm file is always packaged in dtp files in practice so only the load from + memory version is implemented. + All textures are loaded into the video memory during the process, so make sure + SMELT is initialized before calling this function. +-void close() + Close the anm file, free all textures and do the cleanup. +-smTexInfo* getTextureInfo(const char* name) + Gets the details of the texture with the given name. +-smAnmInfo* getAnimationInfo(const char* name) + Gets the details of the animation with the given name. + +2D animated entity class: smAnimation2D +smAnimation2D is derived from the smEntity2D class. +-Constructor from a smAnmInfo class +-void updateAnim(int f=1) + Updates the animation with frame step f. +-void resetAnim() + Resets the animation. + +3D animated entity class: smAnimation3D +smAnimation3D is derived from the smEntity3D class. +-Constructor from a smAnmInfo class +-void updateAnim(int f=1) + Updates the animation with frame step f. +-void resetAnim() + Resets the animation. +smBMFont======================================================================= +The extension provides support of bitmap font rendering. +Bitmap font used by SMELT is described in anm format, with a different meta +file. + +Two classes are provided: smBMFont and smBMFontw. smBMFont accepts char stings +and smBMFontw accepts wchar strings. Their interfaces are the same. + +smBMFontw uses std::map, so huge font files are discouraged. + +Public members of smBMFont(w): +-loadAnmFromMemory(char* ptr,DWORD size) + Loads an anm file describing the font from the given memory block. +-close() + Closes the anm file and frees any resources used by the class. +-render(float x,float y,float z,int align,float *rw,const char*/wchar_t* text) + Render the given text at (x,y,z) with the given align. + ailgns can be one of the macros ALIGN_LEFT/ALIGN_RIGHT/ALIGN_CENTER. + if rw is not NULL, the width of the string will be returned to the pointer. + '\n' is processed correctly. Other control characters are not processed and + may not render correctly. +-printf(float x,float y,float z,int align,float *rw,const wchar_t* format,...) + Render formated string at (x,y,z) with the given align. + The parameters are the same as the render function. +-setColor(DWORD col) + Sets the color for the next rendering. +-setBlend(int blend) + Sets blending mode for the next rendering. +-setScale(int scale) + Sets the font scaling. + +smColor======================================================================== +The extension implements two color classes: smColorRGBA and smColorHSVA. + +Public members of smColorRGBA: +-float r,g,b,a R/G/B/A components, ranged 0..1 +-Default construction op Sets all components to zero +-Construction op from a hardware color +-Construction op from components +-Default destuction op +-void clamp() clamps all components to their range +-operator + - * color operations +-operator * / scalar operations +-void setHWColor(DWORD col) Sets the color accroding to the given + hardware color +-DWORD getHWColor() Gets the hardware color. The color is + automatically clamped. + +Public members of smColorHSVA: +-float h,s,v,a R/G/B/A components, ranged 0..1 +-Default construction op Sets all components to zero +-Construction op from a hardware color +-Construction op from components +-Default destuction op +-void clamp() clamps all components to their range +-operator + - * color operations +-operator * / scalar operations +-void setHWColor(DWORD col) Sets the color accroding to the given + hardware color +-DWORD getHWColor() Gets the hardware color. The color is + automatically clamped. + +smDataPack===================================================================== +The extension implements a data packaging method for increased integrity. +smDtpFileR is used to read a dtp file, while smDtpFileW is used to create a +dtp file. +The format of the dtp file is described in the file datapackFormat. + +Public members of smDtpFileR: +-bool openDtp(const char* path) + Opens a compressed dtp from the given path. + Returns true on succeed, false on failure. +-bool openDtpFromMemory(char* ptr,DWORD size) + Opens a uncompressed dtp from the memory block. + Returns true on succeed, false on failure. +-void closeDtp() + Close the opened dtp file. Release any internal allocated resources. +-char* getFirstFile() + Returns the internal path of the first file in the dtp. +-char* getLastFile() + Returns the internal path of the last file in the dtp. +-char* getNextFile(const char* path) + Returns the internal path of the next file in the dtp. +-char* getPrevFile() + Returns the internal path of the previous file in the dtp. +-char* getFilePtr(const char* path) + Get the pointer to the file required. + The file is loaded into memory during the process. +-void releaseFilePtr(const char* path) + Release the file in the memory. + Always free the file with this function. +-DWORD getFileSize(const char* path) + Get the file size in bytes of the file required. + +Public members of smDtpFileW: +-bool addFile(const char* path,const char* realpath) + Adds a file to the temporary dtp. + path is used as the internal path, realpath is the path of the data + to be packed. +-bool writeDtp(const char* path) + Writes the temporary dtp to a file. + The dtp file is compressed. + The temporary dtp file is deleted after the process. + +A simple DaTaPack utility implementation is in the folder dtputil. +smEntity======================================================================= +The extension implements two entity classes for easy entity rendering. + +Public members of smEntity2D: +-Consturction op from texture and + texture rectangle(SMTEX,float,float,float,float) +-Construction op from texture and + texture rectangle(SMTEX,smTexRect) +-Construction op from another smEntity2D +-Destuction op +-void Render(float x,float y,float rot,float wsc,float hsc) + Renders the entity at (x,y) with rotation rot (optional, in radians). + wsc/hsc (optional) controls the scaling in width and height. + if hsc is omitted, wsc is used as hsc. By default, wsc=1. +-void setTexutre(SMTex tex) + Sets the texture of the entity. +-void setTextureRect4f(float _x,float _y,float _w,float _h) + void setTextureRectv(smTextRect rect) + Sets the area of texture used for rendering. +-void setColor(DWORD col,int v) + Sets the color of the entity or one of the vertexes of the entity. + If v is omitted or v is out of the range 0..3, all four vertexes are + re-colored. +-void setZ(float z,int v) + Sets the z value of the entity or one of the vertexes of the entity. + If v is omitted or v is out of the range 0..3, all four vertexes are + re-positioned. +-void setBlend(int blend) + Sets the blend mode of the entity. The macros BLEND_* are used. +-void setCentre(float x,float y) + Sets the centre of the entity. The centre is used as the rotation centre. + When rendered, the centre is used to position the entity. + +smEntity3D is almost the same as smEntity2D, except the lack of setZ function +and some difference in the rendering methods. Further more, smEntity3D always +writes to the Z buffer when rendered. +-void Render9f(float x,float y,float z,float ra,float rx,float ry,float rz, + float wsc,float hsc) + Renders the 3D entity at (x,y,z). + The entity is rotated by the parameters (ra,rx,ry,rz), in which ra specifies + the angle of rotation in radians and (rx,ry,rz) specify the rotation axis. + The rotation parameters are optional. The vector (rx,ry,rz) is automatically + normalized. + wsc/hsc (optional) controls the scaling in width and height. + if hsc is omitted, wsc is used as hsc. By default, wsc=1. +-void Renderfv(float* pos,float* rot,float* scale) + Equivalent to Render9f(pos[0],pos[1],pos[2],rot[0],rot[1],rot[2],rot[3] + scale[0],scale[1]). + +smGrid========================================================================= +The extension implements a grid used for rendering distorted entity. +Grid sample: ++-----+-----+ +| | | +| | | +| | | ++-----+-----+ +| | | +| | | +| | | ++-----+-----+ +This is a simple 3*3 grid, undistorted. If we fit a texture onto it we will +see a rectangle with that texture. +Now we can distort it like this: ++-----+-----+ + \ \ \ + \ \ \ + \ \ \ + +-----+-----+ + \ \ \ + \ \ \ + \ \ \ + +-----+-----+ +If we fit a texture onto this grid, we will see a parallelogram (probably +glitched because it's only a 3*3 grid). +The grid looks better when the resolution is higher. +With this extension we can implement water/lens/wrapping effect and curved +lasers easily. +The indicatorCircular in the smIndicator extension is also implemented with +smGrid. + +Public members of smGrid: +-Default construction op (int,int) + This construction op requires the column&row count of the grid. +-Copy construction op(const smGrid ©) + Constructs a new smGrid copying the given one. +-Default destuction op. +-operator = +-void render(float x,float y) + Renders the grid at (x,y). (x,y) is the top left coordinate. +-void clear(DWORD color) + Resets the grid with the optional color. +-void setTexutre(SMTEX tex) + Sets the texture of the grid. +-void setTextureRect4f(float _x,float _y,float _w,float _h) + void setTextureRectv(smTexRect rect) + Sets the texture region used by the grid. +-void setBlend(int blend) + Sets the blend mode of the grid. +-void setColor(int c,int r,DWORD col) + Sets the color of the node at row r column c. + You can create interesting colorful effects with this. +-void setPos(int c,int r,float x,float y,float z,int ref) + Sets the positioning of the node at row r column c. + The z value is always directly set. + The x/y values are set according the reference setting. + Possible references are: + GRID_REFNODE: reference point is the node position of a regular grid + GRID_REFTOPLEFT: reference point is the top left corner of the grid + GRID_REFCENTER: reference point is the centre of the grid + GRID_REFCURRENT: reference point is the current position of the node + +smIndicator==================================================================== +The extension implements several value indicators. + +Public members of class indicatorCircular/indicatorLinear: +-void init(double r,double thkns,BYTE a,SMTEX tex,smTexRect tr) + Initialize the indicator with radius r, thickness thkns. + a is used as the initial alpha. +-void overrideColor(DWORD col) + Overrides the default dynamic color with the static color. +-void setAlpha(BYTE a) + Sets the indicator alpha +-void setValue(double v) + Sets the value indicated by the indicator. + The value should be within 0..1. + +smMath========================================================================= +The extension provides several math routines. + +Common math routines: +double smMath::deg2rad(double deg) converts degree to radian +double smMath::rad2deg(double deg) converts radian to degree +double smMath::clamprad(double a) clamps the given angle to [0,2*PI] +double smMath::clampdeg(double a) clamps the given angle to [0,360] + +2D Vector: smvec2d +double x,y coordinates +Constructor(double,double) constructs the vector with the given + coordinates +Default constructor +double l() returns the length of the vector +void normalize() normalizes the vector +smvec2d getNormalized() returns the normalized vector +void swap() swaps the x,y coordinates +void rotate(double rad) rotate the vector by rad radians +smvec2d getRotate(double rad) returns the rotated vector +smvec2d operator - + +smvec2d/double operator * scalar/(length of) cross product +double operator | point product +double operator ^ angle between the vectors + +3D Vector: smvec3d +double x,y,z coordinates +Constructor(double,double,double) constructs the vector with the given + coordinates +Constructor(smvec2d) constructs the vector from the 2d + vector with z=0 +Default constructor +double l() returns the length of the vector +void normalize() normalizes the vector +smvec3d getNormalized() returns the normalized vector +smvec3d operator - + +smvec3d operator * scalar/cross product +smvec3d operator | point product +double operator ^ angle between the vectors + +Transformation matrix: smMatrix +double m[16] +sf 0 1 2 3 +0 00 04 08 12 +1 01 05 09 13 +2 02 06 10 14 +3 03 07 11 15 +Default constructor +Copy constructor +operator [] with this you can access the matrix + like (smMatrix)a[col][row] +void clear() sets the whole matrix to 0 +void loadIdentity() sets the matrix to the identity matrix +void rotate(double,double,double,double) + rotates the vector by (a,x,y,z) where + a is the rotation angle in radians and + (x,y,z) is the rotation axis. +void lookat(double *eye,double *at,double *up) + all vectors have three elements. + This function produces a "look at" + matrix. + When the identity view matrix is + multiplied by the "look at" matrix, it + seems that you are at the "eye" + position, looking at the "at" opsition. + The up vector is used to determine the + pitch of the camera. +operator * Matrix-matrix multiplication. +operator * Matrix-vector multiplication. +smProgresser=================================================================== +The extension implements several progressers useful for making transitions. +All progressers work in the same way: it returns a value within [a,b] according +to the current progress. + +All progresser have these functions publicly accessible: +void init(double _a,double _b,double _lim,[additional parameters]) +Initializes the progresser with a=_a, b=_b and maximum progress _lim. +void launch() +Launch the progresser. This function actually resets the progresser. +void update(double delta) +Updates the progress with delta value delta. +bool isDone() +Check if the progresser has completed its progress. +double getValue() +Gets the current progresser value. +double getPercentage() +Gets the current progress percentage(always linear). +double getDelta() +Gets the current delta between progresser value and a. +double getElapsed() +Gets the current elapsed progress. + +Currently two types of progressers are implemented. +-smProgresserLinear +Normal linear progresser. +-smProgresserCurve +Curve progresser. This progresser requires an additional parameter to +Initialize, which is the radius of the curve. The bigger abs(curvepara) is, +the steeper the progressing curve will be. If curvepara=0, it will act +as the linear progresser. The sign of the parameter controls the bending +direction of the curve. + +smRandom======================================================================= +The extension implements a pseudo random number generator. +Pseudo random number generator always generates the same sequence of number +provided that the seed and the calling sequence is the same. + +Public members of smRandomEngine +void setSeed(unsigned int seed) +Sets the random seed. The seed affects the next number generated. +int nextInt(int min,int max) +Generate a random integer. The seed is updated too. +Please note that max is not necessarily greater than min. +double nextDouble(double min,double max) +Generate a random double. The seed is updated too. +Please note that max is not necessarily greater than min. +smTTFont======================================================================= +The extension implements a freetype interface for SMELT. +Two classes are implemented: smTTChar and smTTFont. smTTChar is implemented for +internal use and should not be used outside the smTTFont class. Class smTTFont +provides all interfaces for font rendering. + +smTTFont uses std::map to cache character glyphs. The cache is manually managed +by the application. A cache too large in size may cause lags. + +Public members of smTTFont: +-bool loadTTF(const char* path,int pt) + Loads a font from the given path. pt is used as the size of the font in + points. +-bool loadTTFFromMemory(char* ptr,DWORD size,int pt) + Loads a font from the given memory block. pt is used as the size of the font + in points. +-void releaseTTF() + Clear the cache and release the loaded font. +-float getWidth() +-float getHeight() + Gets the width/height of the buffered string. + The buffered string is modified by the updateString function. +-void updateString(const wchar_t *format,...) + Update the buffered string. + Update the buffer only when you need to do so because this function is + relatively slow. + '\n' is processed correctly. + If a char is in the internal cache, it will be reused. Otherwise it will be + added to the cache. +-void render(float x,float y,DWORD col,int align) + Renders the buffered string. + The align mode ALIGN_CENTER is not supported. + (x,y) defines the top-left coordinate of the rendered text when using + ALIGN_LEFT while it defines the bottom-right coordinate when using + ALIGN_RIGHT. + col defines the color of the rendered text. +-DWORD getCacheSize() + Gets the internal cache size. + It is advised to keep the cache size relatively low, generally below + 100 thousand. +-void clearCache() + Clear the internal cache.
\ No newline at end of file |