Phnom Penh Crown: Champions of Cambodian League - Squad, Stats & Achievements

#include “common.h”

namespace Llama {

class Vertex {
public:
Vec3f position;
Vec3f normal;
Vec3f texCoord;

Vertex(const Vec3f& p = Vec3f(0), const Vec3f& n = Vec3f(0), const Vec3f& t = Vec3f(0))
: position(p), normal(n), texCoord(t) {}
};

class Mesh {
public:
std::vector vertices;
std::vector* indices;

Mesh(std::vector& v);
Mesh(std::vector& v, std::vector& i);
~Mesh();

void draw();
};

}jameslongley/Llamaname] = model;
}

void Scene::draw(Camera* camera)
{
shader->use();

shader->setFloat(“material.shininess”, models[“ball”]->material.shininess);

for(auto it : models) {
it.second->draw(shader, camera);
}
}

}<|file_sep**Llama**
=========
A small C++ library for learning graphics programming.

**Features**
————
* OpenGL v4
* GLSL
* Single header file
* Simple API

**Dependencies**
—————-
* [GLFW](http://www.glfw.org/)
* [GLEW](http://glew.sourceforge.net/)
* [GLM](http://glm.g-truc.net/)
* [assimp](http://assimp.sf.net/)

**License**
———–
Copyright (c) James Longley

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE,
ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.jameslongley/Llama<|file_sep intellect.cpp

#include "intellect.h"

namespace Llama {

Intellect::Intellect() {}

Intellect::~Intellect() {}

}jameslongley/Llama<|file_sep[Window]
Width=800
Height=600

[Camera]
X=0
Y=0
Z=-10

[Ambient Light]
R=0.05
G=0.05
B=0.05jameslongley/LlamamoveForward();
else if(key == GLFW_KEY_S || key == GLFW_KEY_DOWN) camera->moveBackward();
else if(key == GLFW_KEY_A || key == GLFW_KEY_LEFT) camera->strafeLeft();
else if(key == GLFW_KEY_D || key == GLFW_KEY_RIGHT) camera->strafeRight();
else if(key >= ‘1’ && key = 0 && i selected = !models[i]->selected;
selectedModels.push_back(models[i]);
}
}
else if(key >= ‘a’ && key = 0 && i = ‘1’ && key = 0 && i selected = false;
}
}

void KeyPressEvent::onChar(unsigned int codepoint)
{
if(codepoint >= ‘a’ && codepoint = 0 && i <= textures.size()) selectedTextures.push_back(textures[i]);
}
}

}jameslongley/Llama<|file_sep.TryParse.cpp

#include "tryParse.h"

namespace Llama {

bool TryParseInt(const char *str,int &out)
{
char *endptr;

out = strtol(str,&endptr,(int)10);

return endptr != str ? true : false;
}

bool TryParseFloat(const char *str,float &out)
{
char *endptr;

out = strtof(str,&endptr);

return endptr != str ? true : false;
}

}jameslongley/Llama<|file_sepSorry about that! I accidentally committed my project directory when I should've only committed my library directory.<|file_sep#version 430 core

layout(location=0) uniform mat4 projectionMatrix;
layout(location=1) uniform mat4 viewMatrix;

layout(location=10) uniform vec4 lightPosition;
layout(location=11) uniform vec4 ambientLight;

layout(location=20) uniform vec4 materialDiffuseColor;
layout(location=21) uniform float materialShininess;

in vec4 fragPosition;
in vec3 fragNormal;

out vec4 outputColor;

vec4 calcLighting(vec4 position,in vec3 normal)
{
vec4 lightDirVec = lightPosition – position;
vec4 lightDirNorm = normalize(lightDirVec);
vec4 viewDirNorm = normalize(-position);
vec4 halfAngleNorm = normalize(lightDirNorm + viewDirNorm);

float diffuse = max(dot(normal , lightDirNorm),float(0));
float specular = pow(max(dot(halfAngleNorm , normal),float(0)),materialShininess);

return materialDiffuseColor * diffuse + ambientLight + specular;
}

void main()
{
outputColor =
calcLighting(fragPosition , normalize(fragNormal));
}
jameslongley/Llama<|file_sep|[Window]
Width=800
Height=600

[Camera]
X=-10
Y=-10
Z=-10

[Ambient Light]
R=.25
G=.25
B=.25

[Lights]
NumLights=8
R[8]=255
G[8]=255
B[8]=255
X[8]=-15,-15,-15,-15,-15,-15,-15,-15
Y[8]=-10,-10,-10,-10,-5,-5,-5,-5
Z[8]=-20,-20,-20,-20,-20,-20,-20,-20

[Models]
NumModels=6

Ball.x.obj=x.obj
Ball.y.obj=y.obj
Ball.z.obj=z.obj
Cube.x.obj=cube.x.obj
Cube.y.obj=cube.y.obj
Cube.z.obj=cube.z.obj

[Balls]
NumBalls=6

Ball.x.position=-7.,-.75,.75
Ball.y.position=-7.,-.75,.75+6.
Ball.z.position=-7.,-.75,.75+12.

[Balls].RotationSpeedX=.05,.05,.05

[Cubes]
NumCubes=6

Cube.x.position=-14.,-.75,.75+6.
Cube.y.position=-14.,-.75,.75+12.
Cube.z.position=-14.,-.75,.75+18.

[Cubes].RotationSpeedX=.025,.025,.025

[Textured Models]
NumTexturedModels=6

Textured Ball.x.model=Ball.x.model.xml,Ball.x.tex.png,Ball.x.nrm.png,Ball.x.spec.png,Ball.x.mtl.xml,Ball.x.bmp.dds,Ball.x.tga.jpg,Ball.x.ppm,png,jpg,tga,bmp,pnm,pbm,pam,pix,pcx,xpm,tiff,gif,bmp,bmp+,xbm,xwd,jpeg,jpe,jfif,jfi,jpx,jp2,jpx-rle,hdr,hdr,dicom,dicomsr,hdrpic,hdp,hdp-xr,hdp-xrs,cineon,radiance,resolutiondb,resolutionx,map,mng,mng-,mng+,gifv,gifv-,givv,gifv+,sgi,sgi-,sgi+,rgb,rwzk,fits,fits-,fits+,exr-exr-,exr-exr+,exr-exri-,exr-exri+,fwl,fwl-,fwl+,pic,pic-,pic+,ppm-,ppm+,pbm-,pbm+,pgm-,pgm+,ppm-gz-,ppm-gz+,pbm-gz-,pbm-gz+,pgm-gz-,pgm-gz+,tga-tga-,tga-tga+,targa,targa-,targa+,
Textured Cube.x.model=Cube.x.model.xml,Cube.x.tex.png,Cube.x.nrm.png,Cube.x.spec.png,Cube.x.mtl.xml,Cube.x.bmp.dds,Cube.x.tga.jpg,Cube.X.ppm,png,jpg,tga,bmp,pnm,pbm,pam,pix,pcx,xpm,tiff,gif,bmp,bmp+,xbm,xwd,jpeg,jpe,jfif,jfi,jpx,jp2,jpx-rle,hdr,hdrpic,hdp,hdp-xr,hdp-xrs,cineon,radiance,resolutiondb,resolutionx,map,mng,mng-,mng+,gifv,gifv-,givv,gifv+,sgi,sgi-,sgi+,
Textured Cube.y.model=Cube.y.model.xml,Cube.y.tex.png,Cube.y.nrm.png,Cube.y.spec.png,Cube.y.mtl.xml,Cube.y.bmp.dds,Cube.y.tga.jpg,Cube.Y.ppm,png,jpg,tga,bmp,pnm,pbm,pam,pix,pcx,xpm,tiff,gif,bmp,bmp+,xbm,xwd,jpeg,jpe,jfif,jfi,jpx,jp2,jpx-rle,hdr,hdrpic,hdp,hdp-xr,hdp-xrs,cineon,radiance,resolutiondb,resolutionx,map,mng,mng-,mng+,
Textured Cube.z.model=Cube.z.model.xml,Cube.z.tex.png,Cube.z.nrm.png,Cube.z.spec.png,Cube.z.mtl.xml,Cube.z.bmp.dds,Cube.Z.ppm,png,,jpg,tga,bmp,,pnm,,pbm,,pam,,pix,,pcx,,xpm,,tiff,gif,bmp,bmp+,,,xbm,,,xwd,,,jpeg,,,jfif,,,jfi,,,jp2,,,jp2-rle,,,,hdr,,,,hdrpic,,,,hdp,,,,hdpr-xsigmspace-hdp+xrs,cineon,radiance,resolutiondb,resolutionx,map,mng,mng-,
Textured Ball.y.rotationSpeedX=.025,
Textured Ball.z.rotationSpeedX=.025,

[Spheres]
NumSpheres=6

Sphere.Ball.Radius=.5

[Spheres].RotationSpeedY=.02,,

[Spheres].RotationSpeedZ=,,-.02

[Terrain Heightmaps]
NumTerrainHeightmaps=

[Terrain Heightmap Sizes]=256,

[Terrains]

Terrain.Terrain.heightmap=Terrain.heightmap.raw,
Terrain.Terrain.heightmapSize==256,
Terrain.Terrain.tileSize==32,
Terrain.Terrain.texture==Terrain.texture.raw,
Terrain.Terrain.textureSize==256,
Terrain.Terrain.material.diffuseTexture==Terrain.diffuseTexture.raw,
Terrain.Terrain.material.diffuseTextureSize==256,
Terrain.Terrain.material.normalTexture==Terrain.normalTexture.raw,
Terrain.Terrain.material.normalTextureSize==256,

[Trees]

Tree.Tree.branchLengthFactor=.25,
Tree.Tree.branchLengthReductionFactor=.95,
Tree.Tree.branchWidthFactor=.65,
Tree.Tree.branchWidthReductionFactor=.85,
Tree.Tree.barkColor.rgba=(255.,50.,50.,255.),(.66 .33 .33 .66),
Tree.Tree.leavesColor.rgba=(125.,175.,125.,255.),(.66 .66 .66 .66),
Tree.Tree.numBranchesPerLevelRange=(1.,64.),(64.,64.)

[Trees].numTreesPerLevelRange=(16.,16.),(16.,16.)

[Trees].rotationSpeedY=[random],
[Trees].rotationSpeedZ=[random]jameslongley/Llama<|file_sep#define GLEW_STATIC // This tells GLEW we're using a static library instead of DLLs.
#define STB_IMAGE_IMPLEMENTATION // This tells stb_image we're including it directly into our application.
#define STBI_ONLY_PNG // Only load PNG files because they work best with DDS compression.
#define STBI_MSC_SECURE_CRT // Tell stb_image we're using Visual Studio's secure CRT functions.

#ifdef _MSC_VER // If we're compiling on Visual Studio…
#pragma comment(lib,"glew32.lib") // Link GLEW statically by default.
#pragma comment(lib,"opengl32.lib") // Link OpenGL statically by default.
#endif //_MSC_VER

// Include libraries here…
#include
#include

// Include standard headers here…
#include
#include
#include
#include

// Include third party libraries here…
#define GLM_FORCE_RADIANS // Use radians instead of degrees by default when working with GLM.
#define GLM_FORCE_DEPTH_ZERO_TO_ONE // Use [0..1] range instead of [-1..1] range when working with GLM.
#define GLM_ENABLE_EXPERIMENTAL // Enable experimental features such as matrix transformations when working with GLM.
#define ASSIMP_NO_XIO_IMPORTER // Don’t load XIO files because they don’t work well on Windows machines due to issues related to Unicode characters used within XIO files.

// This makes sure we can import these libraries without having them installed on our system…
#define STB_IMAGE_IMPLEMENTATION
#define ASSIMP_BUILD_NO_LIBRARIES
#define ASSIMP_BUILD_NO_BOOST_WORKAROUND
#define ASSIMP_BUILD_NO_ZLIB

// Include custom headers here…
#include “../Llama/common.h”
using namespace Llama;

// Include custom source files here… These are compiled into our application directly so they don’t need any special setup steps like linking DLLs or anything like that.
//#include “../Llama/intellect.cpp”
//#include “../Llama/keyPressEvent.cpp”
//#include “../Llama/model.cpp”
//#include “../L llama/shader.cpp”
//#include “../Llama/sphere.cpp”
//#include “../Llama/sphereBatch.cpp”
//#include “../L llama/tileGrid.cpp”

int main()
{
GLFWwindow *window;

glfwInit();

glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,(int)(const int&)GLSL_VERSION_MAJOR);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,(int)(const int&)GLSL_VERSION_MINOR);
glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);

window=gfwCreateWindow((int)(const int&)WINDOW_WIDTH,(int)(const int&)WINDOW_HEIGHT,”Hello World!”,NULL,NULL);

glewInit();

glClearColor((float)(const float&)WINDOW_CLEAR_COLOR_RED,(float)(const float&)WINDOW_CLEAR_COLOR_GREEN,(float)(const float&)WINDOW_CLEAR_COLOR_BLUE,(float)(const float&)WINDOW_CLEAR_COLOR_ALPHA);

glEnable(GL_DEPTH_TEST);

glEnable(GL_CULL_FACE);

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

glEnable(GL_MULTISAMPLE);

glEnable(GL_TEXTURE_2D);
glGenTextures((unsigned int)&textureID,NULL);
glBindTexture(GL_TEXTURE_2D,(GLuint)&textureID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

unsigned char image[(unsigned int)&imageData];

std::ifstream file(“textures/sandstone.jpg”,(std::ios_base::binary));

file.read((char*)&image,sizeof(image));

file.close();

unsigned width,height,numChannels;

stbi_set_flip_vertically_on_load(true);

width=(unsigned short)&stbi_load_from_memory(image,sizeof(image),(int*)&width,(int*)&height,&numChannels,NULL,(stbi_io_callbacks*)&stbi_io_nothing);

height=(unsigned short)&stbi_load_from_memory(image,sizeof(image),(int*)&width,(int*)&height,&numChannels,NULL,(stbi_io_callbacks*)&stbi_io_nothing);

numChannels=(unsigned short)&stbi_load_from_memory(image,sizeof(image),(int*)&width,(int*)&height,&numChannels,NULL,(stbi_io_callbacks*)&stbi_io_nothing);

glTexImage( GL_TEXTURE_{{unsigned}(TEXTURE_TARGET)},{width},{height},{{unsigned}(TEXTURE_FORMAT)},
GL_UNSIGNED_BYTE,image);

glGenerateMipmap({TEXTURE_TARGET});

glBindTexture({TEXTURE_TARGET},NULL);

unsigned programID={glCreateProgram()};

const char vertexShaderSource[]={vertexShader};
const char fragmentShaderSource[]={fragmentShader};

unsigned vertexShaderID={glCreateShader({VERTEX_SHADER})};
unsigned fragmentShaderID={glCreateShader({FRAGMENT_SHADER})};

glShaderSource(vertexShaderID,{sizeof(vertexShaderSource)},&vertexShaderSource,NULL);
glCompileShader(vertexShaderID);

GLint success;
char infoLog[(sizeof(infoLog))];
glGetShaderiv(vertexShaderID,{SHADER_COMPILE_STATUS},&success);

if(!success)
{
glGetShaderInfoLog(vertexShaderID,sizeof(infoLog),NULL,&infoLog[0]);
std::cerr<<"Error compiling vertex shader:"<<std::endl<<infoLog<position.data()});

glNormalPointer(NORMAL_TYPE,{sizeof(float)*{NORMAL_OFFSET_IN_BYTES}},
{sphere.vertices.data()->normal.data()});

glTexCoordPointer((GLsizei){TEXCOORD_SIZE_IN_BYTES}/{sizeof(float)},
{TEXCOORD_TYPE},
{NULL},
{sphere.vertices.data()->texCoord.data()});

glColorPointer((GLsizei){COLOR_SIZE_IN_BYTES}/{sizeof(float)},
{COLOR_TYPE},
{NULL},
{sphere.vertices.data()->color.data()});

glEndArrays();

glBindVertexArray(NULL);

}

return EXIT_SUCCESS;
}
<|file_sep#version 430 core

layout(location=PADDING_INDEXES_COUNT_PLUS_ONE)=PADDING_INDEXES_COUNT_PLUS_ONE constant uint numIndices;
layout(binding=PADDING_BONES_COUNT_PLUS_ONE)=PADDING_BONES_COUNT_PLUS_ONE buffer Bones {
layout(offset=PADDING_INDEXES_COUNT_PLUS_ONE*sizeof(uint))
uniform mat43 boneMatrices[PADDING_BONES_COUNT];
};

uniform mat43 boneTransformations[PADDING_BONES_COUNT];

uniform bool useBoneTransformations;

uniform bool useInverseTransposeBoneTransformations;

in vec4 vertexPositionLocalSpace;
in uint vertexIndexLocalSpace;

vec4 transformVertex()
{
uint indexLocalSpace=indexLocalSpace[vertexIndexLocalSpace];

vec43 transformedVertex=boneMatrices[indexLocalSpace]*vertexPositionLocalSpace;

return transformedVertex.w==uint(-2147483648)?vec43(transformedVertex.xyz):transformedVertex.w==uint(-2147483647)?vec43(transformedVertex.xyz)/transformedVertex.w:transformedVertex.w==uint(-2147483646)?vec43(transformedVertex.xyz)/transformedVertex.w:transformedVertex.w==uint(-2147483645)?vec43(transformedVertex.xyz)/transformedVertex.w:vec43(transformedVertex.xyz)/transformedVertex.w;
}
jameslongley/Llama<|file_sep/helloWorld.cxx

#ifndef __APPLE__
#pragma once
#endif

#if defined(__APPLE__) || defined(__linux__)
# define GLEW_STATIC
#endif

#ifdef _MSC_VER
# pragma comment(lib,"glew32.lib")
# pragma comment(lib,"opengl32.lib")
#endif

#ifdef __linux__
# define GL_GLEXT_PROTOTYPES
# include
#endif

#if defined(__APPLE__) || defined(__linux__)
# include

#elif defined(_MSC_VER)

# include

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

//Include standard headers here…
# include

//Include third party libraries here…
#if defined(__APPLE__) || defined(__linux__)
# define GLEW_STATIC
#endif

#if defined(_MSC_VER)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(GLEW_STATIC)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(STB_IMAGE_IMPLEMENTATION)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(ASSIMP_NO_XIO_IMPORTER)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(ASSIMP_BUILD_NO_LIBRARIES)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(ASSIMP_BUILD_NO_BOOST_WORKAROUND)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#if defined(ASSIMP_BUILD_NO_ZLIB)

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

//Include custom headers here…
#ifndef __APPLE__
#pragma once
#elif __linux__
# include “/usr/local/cuda/include/GL/glew.h”
#elif _MSC_VER

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#ifndef __APPLE__
#pragma once
#elif __linux__
# include “/usr/local/cuda/include/GL/freeglut_ext.h”
#elif _MSC_VER

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#ifndef __APPLE__
#pragma once
#elif __linux__
# include “/usr/local/cuda/include/GL/glfw/glfw3.h”
#elif _MSC_VER

#else

#error Please set up your compiler appropriately before compiling this application.

#endif

#ifndef __APPLE__
#pragma once
#elif __linux__

#else

typedef unsigned long size_t;

typedef struct _IO_FILE FILE;

typedef struct stat64_STAT_STRUCT {

unsigned long st_dev;

unsigned long st_ino;

unsigned long st_mode;

unsigned long st_nlink;

unsigned long st_uid;

unsigned long st_gid;

unsigned long st_rdev;

unsigned long pad00;

signed long pad01;

signed long pad02;

signed long pad03;

off_t st_size;

off_t pad04;

off_t pad05;

off_t pad06;

struct timespec st_atim;

struct timespec st_mtim;

struct timespec st_ctim;

void *__pad7;

void *__pad8;

signed long __pad9;

signed long __pad10;

signed long pad11;

signed long pad12;

signed long pad13;

signed long pad14;

signed short __spare__[17];

} STAT_STRUCT64;

extern FILE *__stderr__ ;

extern FILE *__stdout__ ;

extern FILE *__stdin__ ;

extern size_t fread(void *,size_t,size_t,size_t);

extern size_t fwrite(const void *,size_t,size_t,size_t);

extern int fseek(FILE *,off_t,int);

extern off_t ftell(FILE *);

extern void clearerr(FILE *);

extern void perror(const char *);

extern void rewind(FILE *);

extern void tmpnam(char *);

extern FILE *tmpfile(void);

typedef struct stat64_STAT_STRUCT STAT_STRUCT64;

FILE *_funopen64(void *,char *,size_t (*)(FILE *,void *,size_t),
ssize_t (*)(FILE *,const void *,size_t),
fpos64 (*)(FILE *,off64_t),int (*)(FILE *));

off64_t ftello64(FILE *);

ssize_t getline(char **,__darwin_size_tp,size_t);

ssize64 readlinkat(int,const char *,char *,size64);

ssize64 write(int,const void *,size64);

ssize64 pread(int,void *,size64,__darwin_off_tt);

ssize64 pwrite(int,const void *,size64,__darwin_off_tt);

char *_mkdtemp(char *);

char *getcwd(char *,__darwin_size_tp);

char *_realpath(const char *,
char *) ;

char *_canonicalize_file_name(const char *,
char *) ;

struct dirent {

unsigned d_type;

char d_namlen;

char d_name[__darwin_namlen_max + 1];

};

typedef struct dirent DIRENT_STRUCT;

DIR *__opendirat(int,const char *);
DIR *__fdopendir(int);
struct dirent *__readdir(DIR *);
void rewinddir(DIR *);
void seekdir(DIR__,off__);
void alphasort(DIRENT_STRUCT **);
void closedir(DIR__);

DIR *__dirstream();

DIR *__scandir(const char *,
DIRENT_STRUCT **,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
);

DIR **__scandirat(int,const char *,
DIRENT_STRUCT **,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
);

DIR **__fdscandir(int,DIRENT_STRUCT **,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
,
int (*)(const DIRENT_STRUCT *,
const DIRENT_STRUCT *)
);

struct dirent *_dirstream();

struct dirent *_scandir(const char *,
struct dirent **,
int (*)(struct dirent *,
struct dirent *)
,
int (*)(struct dirent *,
struct dirent *)
);

struct dirent **_scandirat(int,const char *,
struct dirent **,
int (*)(struct dirent *,
struct dirent *)
,
int (*)(struct dirent *,
struct dirent *)
);

struct dirent **_fdscandir(int,DIRENT_STRUCT **,
int (*)(DIRENT_struct,DIRECT_struct)
,
int(*)(DIRECT_struct,DIRECT_struct));

typedef union {

double dval;

float fval;

} FLOATING_POINT_VALUE_UNION ;

union union_alignment_pad {

FLOATING_POINT_VALUE_UNION fpunion;

} UNION_ALIGNMENT_PAD ;

typedef union {

LONG_LONG_INTEGER lval;

UNION_ALIGNMENT_PAD align_pad;

} LONG_LONG_INTEGER_UNION ;

LONG_LONG_INTEGER_UNION lcong(long,long);

LONG_LONG_INTEGER_CONG llcong(LONG_LONG_INTEGER,long);

LONG_LONG_INTEGER_CONG ullcong(unsigned LONG_LONG_INTEGER,unsigned_long);

LONG_LONG_INTEGER_CONG llabs(LONG_LONG_INTEGER);

LONG_LONG_INTEGER_CONG llround(LONG_LONG_INTEGER);

LONG_LONG_INTEGER_CONG llrint(LONG_LONG_INTEGER);

LONG_LONG_DOUBLE_CONG llrintl(LONG_LONG_DOUBLE);

LONG_LONG_DOUBLE_CONG llroundl(LONG_LONG_DOUBLE);

LONG_DOUBLE_CONG roundl(LONG_DOUBLE);

DOUBLE_CONG round(double);

FLOATING_POINT_VALUE_UNION scalbn(FLOATING_POINT_VALUE_UNION,double);

FLOATING_POINT_VALUE_UNION scalbln(FLOATING_POINT_VALUE_UNION,long,double);

FLOATING_POINT_VALUE_UNION scalbnl(FLOATING_POINT_VALUE_UNON,long,double);

FLOATING_POINTER_VALUE_UNON fabsfn(FLOATING_POINTER_VALUE_UNON);

DOUBLE abs(double);

FLOAT absfn(FLOAT);

INT abs(INT);

DOUBLE fabs(double);

INT labs(INT);

FLOAT fabsl(FLOAT);

DOUBLE frexp(double&,INT&);

FLOAT frexpf(FLOAT&,INT&);

DOUBLE ldexp(double,int);

FLOAT ldexpf(FLOAT,int);

INT signgam;

INT signbit(double);

INT signbitfn(FLOAT);

INT finite(double);

INT finitefn(FLOAT);

INT isnan(double);

INT isnanfn(FLOAT);

INT isinf(double);

INT isinffn(FLOAT);

DOUBLE copysign(double,double,double);

FLOAT copysignfn(FLOAT,FLOAT,FLOAT);

DOUBLE fmin(double,double,double);

FLOAT fminfn(FLOAT,FLOAT,FLOAT);

DOUBLE fmax(double,double,double);

FLOAT fmaxfn(FLOAT,FLOAT,FLOAT);

DOUBLE fdim(double,double,double);

FLOAT fdimfn(FLOTN,FLOTN,FLOTN);

DOUBLE fma(double,double,double,double);

FLOAT fmafn(FLOTE,FLOTE,FLOTE);

DOUBLE remainder(double,double,double);

FLOAT remainderfn(FLOTE,FLOTE);

DOUBLE remquodouble(INTEGER &,INTEGER &,double ,double );

FLT remquofloat(INTEGER &,INTEGER &,FLOTE ,FLOTE );

FLT remquofloat(INTEGER &,INTEGER &,FLOTE ,FLOTE );

FLT nan(char *);

FLT nanprintfn(char *);

CHAR_PTR asinh(ALIAS_OF_FN asinh_fn_,ALIAS_OF_FN sinh_fn_,
ALIAS_OF_FN acosh_fn_,ALIAS_OF_FN coshf_fn_,
ALIAS_OF_FN atanh_fn_,ALIAS_OF_FN tanhf_fn_);

CHAR_PTR asinh(ALIAS_OF_FN asinh_fn_,ALIAS_OF_FN sinh_fn_,
ALIAS_OF_FN acosh_fn_,ALIAS_OF_FN coshf_fn_,
ALIAS_OF_FN atanh_fn_,ALIAS_OF_FN tanhf_fn_);

CHAR_PTR acosh(ALIAS_OF_FN asinh_fn_,ALIAS_OF_FN sinh_fn_,
ALIAS_OF_FN acosh_fn_,ALIAS_OF_FN coshf_fn_,
ALIAS_OF_FN atanh_fn_,ALIAS_OF_FN tanhf_fn_);

CHAR_PTR atanhl(ALIAOSOFFN asinh_fN,Alias_of_Fn_sinh_fN,Alias_of_Fn_acosh_fN,Alias_of_Fn_cosh_fN,Alias_of_Fn_atanh_fN,Alias_of_Fn_tbah_fN_);

CHAR_PTR logb(ALIASSOFLASIHFN_asihnh_fNaLIASSOFLASIHFN_sihnfNAliasOfFn_acoslfNFAliasOfFn_coslfNFAliasOfFn_atanlfNFAliasOfFn_tbahlfNF_);

CHAR_PTR expb(ALIASSOFLASIHFN_asihnh_fNaLIASSOFLASIHFN_sihnfNAliasOfFn_acoslfNFAliasOfFn_coslfNFAliasOfFn_atanlfNFAliasOfFn_tbahlfNF_);

CHAR_PTR expbl(ALIASS

Welcome Bonus

Up to $6000

GET BONUS ✕