Introduction
Downloads
Documentation
Tutorials
Pixie Lite
Forum

Home

StandardLibrary.h

Go to the documentation of this file.

#ifndef __StandardLibrary_H__
#define __StandardLibrary_H__

int Round(
   float x
   );


const unsigned int RANDOM_MAX=0xffffffff;


unsigned int Rand();


void SRand(
   unsigned int seed 
   );


void Randomize();


int ToUpper(
   int c 
   );


int ToLower(
   int c 
   );


int StringToInt(
   const char* string   
   );

long StringToLong(
   const char* string   
   );


double StringToDouble(
   const char* string   
   );

int SPrintF(
   char* buffer, 
   const char* string,  
   ... 
   );


int SNPrintF(
   char* buffer,  
   int maxLength, 
   const char* string,  
   ...   
   );


char* StrDup(
   const char* string   
   );


int StrNICmp(
   const char* string1, 
   const char* string2, 
   int count   
   );


int StrICmp(
   const char* string1, 
   const char* string2     
   );


int StrCmp(
   const char* string1, 
   const char* string2     
   );


int StrNCmp(
   const char* string1, 
   const char* string2, 
   int count   

   );


unsigned int StrLen(
   const char* string   
   );


char* StrCpy(
   char* strDestination,   
   const char* strSource   
   );


char* StrNCpy(
   char* strDestination,   
   const char* strSource,  
   int count   
   );


char* StrCat(
   char* strDestination,   
   const char* strSource   
   );


char* StrNCat(
   char* strDestination,   
   const char* strSource,  
   int count   
   );


char* StrUpr(
   char* string   
   );


char* StrLwr(
   char* string   
   );


const char* StrChr(
   const char* string,  
   int c 
   );


const char* StrRChr(
   const char* string,  
   int c 
   );


char* StrTok(
   char* strToken,   
   const char* strDelimit  
   );


const char* StrStr(
   const char* str1, 
   const char* str2  
   );


void* Malloc(
   unsigned int size 
   ); 


void Free(
   void* memblock 
   );


void* Realloc(
   void* memblock,   
   unsigned int size 
   );


void* MemCpy(
   void* dest, 
   const void* src,  
   unsigned int count   
   );


void* MemSet(
   void* dest, 
   int c,   
   unsigned int count   
   );


unsigned int MemCmp(
   const void* buf1, 
   const void* buf2, 
   unsigned int count   
   );


void QSort(
   void* base, 
   size_t num, 
   size_t width,  
   int (__cdecl* compare )(const void*, const void*)  


   );


const float PI = 3.1415926535897932384626433832795f;


const float TWO_PI = 2*PI;


const float FLOAT_MAX = 3.402823466e+38f; 


const float FLOAT_MIN = 1.175494351e-38f; 


const float FLOAT_EPSILON = 1.192092896e-07f; 


const int MIN_INT = (-2147483647 - 1);


const int MAX_INT = 2147483647;


float ToRadians(
   float degrees  // Angle to convert, in degrees
   );


float ToDegrees(
   float radians  // Angle to convert, in radians
   );


float AngleDiff(
   float angleA,  // First angle, in radians
   float angleB   // Second angle, in radians
   );


float Abs(
   float x  
   ); 


int Abs(
   int x 
   ); 


int Pow(
   int x,   
   int y 
   ); 


float Pow(
   float x, 
   float y     
   ); 


float Log10(
   float x  
   );


float Sqrt(
   float x  
   );


float Mod(
   float x, 
   float y  
   );


float Sin(
   float x  
   );


float ASin(
   float x  
   );


float Cos(
   float x  
   );


float ACos(
   float x  
   );


float Tan(
   float x  
   );


float ATan(
   float x  
   );

float Atan2(
   float x, 
   float y     
   );


float Exp(
   float x  
   );


float Log(
   float x  
   );


float Max(
   float a, 
   float b 
   );


float Min(
   float a, 
   float b 
   );


int Max(
   int a, 
   int b 
   );


int Min(
   int a, 
   int b 
   );


int Clamp(
   int value,  
   int min, 
   int max     
   );


float Clamp(
   float value,   
   float min,     
   float max      
   );


void Swap(
   int& x,  
   int& y   
   );


void Swap(
   unsigned int& x,  
   unsigned int& y      
   );


void Swap(
   float& x,   
   float& y 
   );




#endif /* __StandardLibrary_H__ */

---

Pixie University and the Pixie Game Engine is created and managed by Mattias Gustavsson.
Reproduction/republishing of any material on this site without permission is strictly prohibited.