#include "raylib.h" // Declares module functions

#include "config.h" // Defines module configuration flags

#if SUPPORT_MODULE_RMODELS

#include "rlgl.h" // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2

#include "raymath.h" // Required for: Vector3, Quaternion and Matrix functionality

#include <stdio.h> // Required for: sprintf()

#include <stdlib.h> // Required for: malloc(), calloc(), free()

#include <string.h> // Required for: memcmp(), strlen(), strncpy()

#include <math.h> // Required for: sinf(), cosf(), sqrtf(), fabsf()

#if SUPPORT_FILEFORMAT_OBJ || SUPPORT_FILEFORMAT_MTL

#define TINYOBJ_MALLOC RL_MALLOC

#define TINYOBJ_CALLOC RL_CALLOC

#define TINYOBJ_REALLOC RL_REALLOC

#define TINYOBJ_FREE RL_FREE

#define TINYOBJ_LOADER_C_IMPLEMENTATION

#include "external/tinyobj_loader_c.h" // OBJ/MTL file formats loading

#if SUPPORT_FILEFORMAT_GLTF

#define CGLTF_MALLOC RL_MALLOC

#define CGLTF_FREE RL_FREE

#define CGLTF_IMPLEMENTATION

#include "external/cgltf.h" // glTF file format loading

#if SUPPORT_FILEFORMAT_VOX

#define VOX_MALLOC RL_MALLOC

#define VOX_CALLOC RL_CALLOC

#define VOX_REALLOC RL_REALLOC

#define VOX_FREE RL_FREE

#define VOX_LOADER_IMPLEMENTATION

#include "external/vox_loader.h" // VOX file format loading (MagikaVoxel)

#if SUPPORT_FILEFORMAT_M3D

#define M3D_MALLOC RL_MALLOC

#define M3D_REALLOC RL_REALLOC

#define M3D_FREE RL_FREE

#define M3D_IMPLEMENTATION

#include "external/m3d.h" // Model3D file format loading

#if SUPPORT_MESH_GENERATION

#define PAR_MALLOC(T, N) ((T *)RL_MALLOC(N*sizeof(T)))

#define PAR_CALLOC(T, N) ((T *)RL_CALLOC(N*sizeof(T), 1))

#define PAR_REALLOC(T, BUF, N) ((T *)RL_REALLOC(BUF, sizeof(T)*(N)))

#define PAR_FREE RL_FREE

#if defined(_MSC_VER) // Disable some MSVC warning

#pragma warning(push)

#pragma warning(disable : 4244)

#pragma warning(disable : 4305)

#endif

#define PAR_SHAPES_IMPLEMENTATION

#include "external/par_shapes.h" // Shapes 3d parametric generation

#if defined(_MSC_VER)

#pragma warning(pop) // Disable MSVC warning suppression

#endif

#if defined(_WIN32)

#include <direct.h> // Required for: _chdir() [Used in LoadOBJ()]

#define CHDIR _chdir

#include <unistd.h> // Required for: chdir() (POSIX) [Used in LoadOBJ()]

#define CHDIR chdir

#ifndef MAX_MATERIAL_MAPS

#define MAX_MATERIAL_MAPS 12 // Maximum number of maps supported

#ifndef MAX_MESH_VERTEX_BUFFERS

#if SUPPORT_GPU_SKINNING

// NOTE: Two additional vertex buffers required to store bone indices and bone weights

// WARNING: Some GPUs could not support more than 8 VBOs

#define MAX_MESH_VERTEX_BUFFERS 9 // Maximum vertex buffers (VBO) per mesh

#define MAX_MESH_VERTEX_BUFFERS 7 // Maximum vertex buffers (VBO) per mesh

#ifndef MAX_FILEPATH_LENGTH

#define MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value)

#if SUPPORT_FILEFORMAT_OBJ

static Model LoadOBJ(const char *fileName); // Load OBJ mesh data

#if SUPPORT_FILEFORMAT_IQM

static Model LoadIQM(const char *fileName); // Load IQM mesh data

static ModelAnimation *LoadModelAnimationsIQM(const char *fileName, int *animCount); // Load IQM animation data

#if SUPPORT_FILEFORMAT_GLTF

static Model LoadGLTF(const char *fileName); // Load GLTF mesh data

static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCount); // Load GLTF animation data

#if SUPPORT_FILEFORMAT_VOX

static Model LoadVOX(const char *filename); // Load VOX mesh data

#if SUPPORT_FILEFORMAT_M3D

static Model LoadM3D(const char *filename); // Load M3D mesh data

static ModelAnimation *LoadModelAnimationsM3D(const char *fileName, int *animCount); // Load M3D animation data

#if SUPPORT_FILEFORMAT_OBJ || SUPPORT_FILEFORMAT_MTL

static void ProcessMaterialsOBJ(Material *rayMaterials, tinyobj_material_t *materials, int materialCount); // Process obj materials

static void UpdateModelAnimationVertexBuffers(Model model);

void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)

{

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

rlVertex3f(startPos.x, startPos.y, startPos.z);

rlVertex3f(endPos.x, endPos.y, endPos.z);

rlEnd();

}

void DrawPoint3D(Vector3 position, Color color)

{

rlPushMatrix();

rlTranslatef(position.x, position.y, position.z);

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

rlVertex3f(0.0f, 0.0f, 0.0f);

rlVertex3f(0.0f, 0.0f, 0.1f);

rlEnd();

rlPopMatrix();

}

void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)

{

rlPushMatrix();

rlTranslatef(center.x, center.y, center.z);

rlRotatef(rotationAngle, rotationAxis.x, rotationAxis.y, rotationAxis.z);

rlBegin(RL_LINES);

for (int i = 0; i < 360; i += 10)

{

rlColor4ub(color.r, color.g, color.b, color.a);

rlVertex3f(sinf(DEG2RAD*i)*radius, cosf(DEG2RAD*i)*radius, 0.0f);

rlVertex3f(sinf(DEG2RAD*(i + 10))*radius, cosf(DEG2RAD*(i + 10))*radius, 0.0f);

}

rlEnd();

rlPopMatrix();

}

void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color)

{

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

rlVertex3f(v1.x, v1.y, v1.z);

rlVertex3f(v2.x, v2.y, v2.z);

rlVertex3f(v3.x, v3.y, v3.z);

rlEnd();

}

void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color)

{

if (pointCount < 3) return; // Security check

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 2; i < pointCount; i++)

{

if ((i%2) == 0)

{

rlVertex3f(points[i].x, points[i].y, points[i].z);

rlVertex3f(points[i - 2].x, points[i - 2].y, points[i - 2].z);

rlVertex3f(points[i - 1].x, points[i - 1].y, points[i - 1].z);

}

else

{

rlVertex3f(points[i].x, points[i].y, points[i].z);

rlVertex3f(points[i - 1].x, points[i - 1].y, points[i - 1].z);

rlVertex3f(points[i - 2].x, points[i - 2].y, points[i - 2].z);

}

}

rlEnd();

}

void DrawCube(Vector3 position, float width, float height, float length, Color color)

{

float x = 0.0f;

float y = 0.0f;

float z = 0.0f;

rlPushMatrix();

// NOTE: Transformation is applied in inverse order (scale -> rotate -> translate)

rlTranslatef(position.x, position.y, position.z);

//rlRotatef(45, 0, 1, 0);

//rlScalef(1.0f, 1.0f, 1.0f); // NOTE: Vertices are directly scaled on definition

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

// Front face

rlNormal3f(0.0f, 0.0f, 1.0f);

rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Right

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right

// Back face

rlNormal3f(0.0f, 0.0f, -1.0f);

rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Left

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left

// Top face

rlNormal3f(0.0f, 1.0f, 0.0f);

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left

rlVertex3f(x - width/2, y + height/2, z + length/2); // Bottom Left

rlVertex3f(x + width/2, y + height/2, z + length/2); // Bottom Right

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left

rlVertex3f(x + width/2, y + height/2, z + length/2); // Bottom Right

// Bottom face

rlNormal3f(0.0f, -1.0f, 0.0f);

rlVertex3f(x - width/2, y - height/2, z - length/2); // Top Left

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right

rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left

rlVertex3f(x + width/2, y - height/2, z - length/2); // Top Right

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right

rlVertex3f(x - width/2, y - height/2, z - length/2); // Top Left

// Right face

rlNormal3f(1.0f, 0.0f, 0.0f);

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Left

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Left

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Left

// Left face

rlNormal3f(-1.0f, 0.0f, 0.0f);

rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Right

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Right

rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left

rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Right

rlEnd();

rlPopMatrix();

}

void DrawCubeV(Vector3 position, Vector3 size, Color color)

{

DrawCube(position, size.x, size.y, size.z, color);

}

void DrawCubeWires(Vector3 position, float width, float height, float length, Color color)

{

float x = 0.0f;

float y = 0.0f;

float z = 0.0f;

rlPushMatrix();

rlTranslatef(position.x, position.y, position.z);

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

// Front face

//------------------------------------------------------------------

// Bottom line

rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom left

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom right

// Left line

rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom right

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right

// Top line

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left

// Right line

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left

rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom left

// Back face

//------------------------------------------------------------------

// Bottom line

rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom left

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom right

// Left line

rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom right

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right

// Top line

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left

// Right line

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left

rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom left

// Top face

//------------------------------------------------------------------

// Left line

rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left front

rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left back

// Right line

rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right front

rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right back

// Bottom face

//------------------------------------------------------------------

// Left line

rlVertex3f(x - width/2, y - height/2, z + length/2); // Top left front

rlVertex3f(x - width/2, y - height/2, z - length/2); // Top left back

// Right line

rlVertex3f(x + width/2, y - height/2, z + length/2); // Top right front

rlVertex3f(x + width/2, y - height/2, z - length/2); // Top right back

rlEnd();

rlPopMatrix();

}

void DrawCubeWiresV(Vector3 position, Vector3 size, Color color)

{

DrawCubeWires(position, size.x, size.y, size.z, color);

}

void DrawSphere(Vector3 centerPos, float radius, Color color)

{

DrawSphereEx(centerPos, radius, 16, 16, color);

}

void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color)

{

#if 0

// Basic implementation, do not use it!

// For a sphere with 16 rings and 16 slices it requires 8640 cos()/sin() function calls!

// New optimized version below only requires 4 cos()/sin() calls

rlPushMatrix();

// NOTE: Transformation is applied in inverse order (scale -> translate)

rlTranslatef(centerPos.x, centerPos.y, centerPos.z);

rlScalef(radius, radius, radius);

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 0; i < (rings + 2); i++)

{

for (int j = 0; j < slices; j++)

{

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));

}

}

rlEnd();

rlPopMatrix();

rlPushMatrix();

// NOTE: Transformation is applied in inverse order (scale -> translate)

rlTranslatef(centerPos.x, centerPos.y, centerPos.z);

rlScalef(radius, radius, radius);

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

float ringangle = DEG2RAD*(180.0f/(rings + 1)); // Angle between latitudinal parallels

float sliceangle = DEG2RAD*(360.0f/slices); // Angle between longitudinal meridians

float cosring = cosf(ringangle);

float sinring = sinf(ringangle);

float cosslice = cosf(sliceangle);

float sinslice = sinf(sliceangle);

Vector3 vertices[4] = { 0 }; // Required to store face vertices

vertices[2] = (Vector3){ 0, 1, 0 };

vertices[3] = (Vector3){ sinring, cosring, 0 };

for (int i = 0; i < rings + 1; i++)

{

for (int j = 0; j < slices; j++)

{

vertices[0] = vertices[2]; // Rotate around y axis to set up vertices for next face

vertices[1] = vertices[3];

vertices[2] = (Vector3){ cosslice*vertices[2].x - sinslice*vertices[2].z, vertices[2].y, sinslice*vertices[2].x + cosslice*vertices[2].z }; // Rotation matrix around y axis

vertices[3] = (Vector3){ cosslice*vertices[3].x - sinslice*vertices[3].z, vertices[3].y, sinslice*vertices[3].x + cosslice*vertices[3].z };

rlNormal3f(vertices[0].x, vertices[0].y, vertices[0].z);

rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z);

rlNormal3f(vertices[3].x, vertices[3].y, vertices[3].z);

rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z);

rlNormal3f(vertices[1].x, vertices[1].y, vertices[1].z);

rlVertex3f(vertices[1].x, vertices[1].y, vertices[1].z);

rlNormal3f(vertices[0].x, vertices[0].y, vertices[0].z);

rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z);

rlNormal3f(vertices[2].x, vertices[2].y, vertices[2].z);

rlVertex3f(vertices[2].x, vertices[2].y, vertices[2].z);

rlNormal3f(vertices[3].x, vertices[3].y, vertices[3].z);

rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z);

}

vertices[2] = vertices[3]; // Rotate around z axis to set up starting vertices for next ring

vertices[3] = (Vector3){ cosring*vertices[3].x + sinring*vertices[3].y, -sinring*vertices[3].x + cosring*vertices[3].y, vertices[3].z }; // Rotation matrix around z axis

}

rlEnd();

rlPopMatrix();

}

void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color)

{

rlPushMatrix();

// NOTE: Transformation is applied in inverse order (scale -> translate)

rlTranslatef(centerPos.x, centerPos.y, centerPos.z);

rlScalef(radius, radius, radius);

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 0; i < (rings + 2); i++)

{

for (int j = 0; j < slices; j++)

{

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices)));

rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),

sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),

cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));

}

}

rlEnd();

rlPopMatrix();

}

void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color)

{

if (sides < 3) sides = 3;

const float angleStep = 360.0f/sides;

rlPushMatrix();

rlTranslatef(position.x, position.y, position.z);

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

if (radiusTop > 0)

{

// Draw Body -------------------------------------------------------------------------------------

for (int i = 0; i < sides; i++)

{

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); //Bottom Left

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); //Bottom Right

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); //Top Right

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop); //Top Left

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); //Bottom Left

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); //Top Right

}

// Draw Cap --------------------------------------------------------------------------------------

for (int i = 0; i < sides; i++)

{

rlVertex3f(0, height, 0);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop);

}

}

else

{

// Draw Cone -------------------------------------------------------------------------------------

for (int i = 0; i < sides; i++)

{

rlVertex3f(0, height, 0);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom);

}

}

// Draw Base -----------------------------------------------------------------------------------------

for (int i = 0; i < sides; i++)

{

rlVertex3f(0, 0, 0);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom);

}

rlEnd();

rlPopMatrix();

}

void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)

{

if (sides < 3) sides = 3;

Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };

if ((direction.x == 0) && (direction.y == 0) && (direction.z == 0)) return; // Security check

// Construct a basis of the base and the top face:

Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction));

Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction));

float baseAngle = (2.0f*PI)/sides;

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 0; i < sides; i++)

{

// Compute the four vertices

float s1 = sinf(baseAngle*(i + 0))*startRadius;

float c1 = cosf(baseAngle*(i + 0))*startRadius;

Vector3 w1 = { startPos.x + s1*b1.x + c1*b2.x, startPos.y + s1*b1.y + c1*b2.y, startPos.z + s1*b1.z + c1*b2.z };

float s2 = sinf(baseAngle*(i + 1))*startRadius;

float c2 = cosf(baseAngle*(i + 1))*startRadius;

Vector3 w2 = { startPos.x + s2*b1.x + c2*b2.x, startPos.y + s2*b1.y + c2*b2.y, startPos.z + s2*b1.z + c2*b2.z };

float s3 = sinf(baseAngle*(i + 0))*endRadius;

float c3 = cosf(baseAngle*(i + 0))*endRadius;

Vector3 w3 = { endPos.x + s3*b1.x + c3*b2.x, endPos.y + s3*b1.y + c3*b2.y, endPos.z + s3*b1.z + c3*b2.z };

float s4 = sinf(baseAngle*(i + 1))*endRadius;

float c4 = cosf(baseAngle*(i + 1))*endRadius;

Vector3 w4 = { endPos.x + s4*b1.x + c4*b2.x, endPos.y + s4*b1.y + c4*b2.y, endPos.z + s4*b1.z + c4*b2.z };

if (startRadius > 0)

{

rlVertex3f(startPos.x, startPos.y, startPos.z); // |

rlVertex3f(w2.x, w2.y, w2.z); // T0

rlVertex3f(w1.x, w1.y, w1.z); // |

}

// w2 x.-----------x startPos

rlVertex3f(w1.x, w1.y, w1.z); // | |\'. T0 /

rlVertex3f(w2.x, w2.y, w2.z); // T1 | \ '. /

rlVertex3f(w3.x, w3.y, w3.z); // | |T \ '. /

// | 2 \ T 'x w1

rlVertex3f(w2.x, w2.y, w2.z); // | w4 x.---\-1-|---x endPos

rlVertex3f(w4.x, w4.y, w4.z); // T2 '. \ |T3/

rlVertex3f(w3.x, w3.y, w3.z); // | '. \ | /

// '.\|/

if (endRadius > 0) // 'x w3

{

rlVertex3f(endPos.x, endPos.y, endPos.z); // |

rlVertex3f(w3.x, w3.y, w3.z); // T3

rlVertex3f(w4.x, w4.y, w4.z); // |

} //

}

rlEnd();

}

void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color)

{

if (sides < 3) sides = 3;

const float angleStep = 360.0f/sides;

rlPushMatrix();

rlTranslatef(position.x, position.y, position.z);

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 0; i < sides; i++)

{

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop);

rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop);

rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom);

}

rlEnd();

rlPopMatrix();

}

void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)

{

if (sides < 3) sides = 3;

Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };

if ((direction.x == 0) && (direction.y == 0) && (direction.z == 0)) return; // Security check

// Construct a basis of the base and the top face:

Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction));

Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction));

float baseAngle = (2.0f*PI)/sides;

rlBegin(RL_LINES);

rlColor4ub(color.r, color.g, color.b, color.a);

for (int i = 0; i < sides; i++)

{

// Compute the four vertices

float s1 = sinf(baseAngle*(i + 0))*startRadius;

float c1 = cosf(baseAngle*(i + 0))*startRadius;

Vector3 w1 = { startPos.x + s1*b1.x + c1*b2.x, startPos.y + s1*b1.y + c1*b2.y, startPos.z + s1*b1.z + c1*b2.z };

float s2 = sinf(baseAngle*(i + 1))*startRadius;

float c2 = cosf(baseAngle*(i + 1))*startRadius;

Vector3 w2 = { startPos.x + s2*b1.x + c2*b2.x, startPos.y + s2*b1.y + c2*b2.y, startPos.z + s2*b1.z + c2*b2.z };

float s3 = sinf(baseAngle*(i + 0))*endRadius;

float c3 = cosf(baseAngle*(i + 0))*endRadius;

Vector3 w3 = { endPos.x + s3*b1.x + c3*b2.x, endPos.y + s3*b1.y + c3*b2.y, endPos.z + s3*b1.z + c3*b2.z };

float s4 = sinf(baseAngle*(i + 1))*endRadius;

float c4 = cosf(baseAngle*(i + 1))*endRadius;

Vector3 w4 = { endPos.x + s4*b1.x + c4*b2.x, endPos.y + s4*b1.y + c4*b2.y, endPos.z + s4*b1.z + c4*b2.z };

rlVertex3f(w1.x, w1.y, w1.z);

rlVertex3f(w2.x, w2.y, w2.z);

rlVertex3f(w1.x, w1.y, w1.z);

rlVertex3f(w3.x, w3.y, w3.z);

rlVertex3f(w3.x, w3.y, w3.z);

rlVertex3f(w4.x, w4.y, w4.z);

}

rlEnd();

}

void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color)

{

if (slices < 3) slices = 3;

Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };

// draw a sphere if start and end points are the same

bool sphereCase = (direction.x == 0) && (direction.y == 0) && (direction.z == 0);

if (sphereCase) direction = (Vector3){0.0f, 1.0f, 0.0f};

// Construct a basis of the base and the caps:

Vector3 b0 = Vector3Normalize(direction);

Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction));

Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction));

Vector3 capCenter = endPos;

float baseSliceAngle = (2.0f*PI)/slices;

float baseRingAngle = PI*0.5f/rings;

rlBegin(RL_TRIANGLES);

rlColor4ub(color.r, color.g, color.b, color.a);

// render both caps

for (int c = 0; c < 2; c++)