objects.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_OBJECTS_HPP
#define CSCI441_OBJECTS_HPP
 
#include "constants.h"
#include "objects_impl.hpp"
#include "teapot.hpp"                   // for teapot()
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <glm/gtc/constants.hpp>
 
#include <cassert>                      // for assert()
 
 
namespace CSCI441 {
    void setVertexAttributeLocations( GLint positionLocation, GLint normalLocation = -1, GLint texCoordLocation = -1, GLint tangentLocation = -1 );
 
    [[maybe_unused]] void deleteObjectVAOs();
 
    [[maybe_unused]] void deleteObjectVBOs();
 
    [[maybe_unused]] void drawSolidCone( GLfloat base, GLfloat height, GLint stacks, GLint slices );
    [[maybe_unused]] void drawWireCone( GLfloat base, GLfloat height, GLint stacks, GLint slices );
 
    [[maybe_unused]] void drawSolidCube( GLfloat sideLength );
    void drawSolidCubeFlat( GLfloat sideLength );
    void drawSolidCubeIndexed( GLfloat sideLength );
    [[maybe_unused]] void drawSolidCubeTextured( GLfloat sideLength );
    [[maybe_unused]] void drawWireCube( GLfloat sideLength );
 
    [[maybe_unused]] void drawCubeMap( GLfloat sideLength );
 
    [[maybe_unused]] void drawSolidCylinder( GLfloat base, GLfloat top, GLfloat height, GLint stacks, GLint slices );
    [[maybe_unused]] void drawWireCylinder( GLfloat base, GLfloat top, GLfloat height, GLint stacks, GLint slices );
 
    [[maybe_unused]] void drawSolidDisk( GLfloat inner, GLfloat outer, GLint slices, GLint rings );
    [[maybe_unused]] void drawWireDisk( GLfloat inner, GLfloat outer, GLint slices, GLint rings );
 
    [[maybe_unused]] void drawSolidPartialDisk( GLfloat inner, GLfloat outer, GLint slices, GLint rings, GLfloat start, GLfloat sweep );
    [[maybe_unused]] void drawWirePartialDisk( GLfloat inner, GLfloat outer, GLint slices, GLint rings, GLfloat start, GLfloat sweep );
 
    [[maybe_unused]] void drawSolidSphere( GLfloat radius, GLint stacks, GLint slices );
    [[maybe_unused]] void drawWireSphere( GLfloat radius, GLint stacks, GLint slices );
 
    [[maybe_unused]] void drawSolidHalfSphere( GLfloat radius, GLint stacks, GLint slices );
    [[maybe_unused]] void drawWireHalfSphere( GLfloat radius, GLint stacks, GLint slices );
 
    [[maybe_unused]] void drawSolidDome( GLfloat radius, GLint stacks, GLint slices );
    [[maybe_unused]] void drawWireDome( GLfloat radius, GLint stacks, GLint slices );
 
    [[maybe_unused]] void drawSolidTeapot( GLfloat unused = 0.0f );
    [[maybe_unused]] void drawWireTeapot( GLfloat unused = 0.0f );
 
    [[maybe_unused]] void drawSolidTorus( GLfloat innerRadius, GLfloat outerRadius, GLint sides, GLint rings );
    [[maybe_unused]] void drawWireTorus( GLfloat innerRadius, GLfloat outerRadius, GLint sides, GLint rings );
}
 
// Outward facing function implementations
 
inline void CSCI441::setVertexAttributeLocations(
    const GLint positionLocation,
    const GLint normalLocation,
    const GLint texCoordLocation,
    const GLint tangentLocation
) {
    CSCI441_INTERNAL::_positionAttributeLocation = positionLocation;
    CSCI441_INTERNAL::_normalAttributeLocation = normalLocation;
    CSCI441_INTERNAL::_texCoordAttributeLocation = texCoordLocation;
    CSCI441_INTERNAL::_tangentAttributeLocation = tangentLocation;
    CSCI441_INTERNAL::setTeapotAttributeLocations(positionLocation, normalLocation, texCoordLocation, tangentLocation);
}
 
[[maybe_unused]]
inline void CSCI441::deleteObjectVAOs() {
    CSCI441_INTERNAL::deleteObjectVAOs();
}
 
[[maybe_unused]]
inline void CSCI441::deleteObjectVBOs() {
    CSCI441_INTERNAL::deleteObjectVBOs();
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidCone(
    const GLfloat base,
    const GLfloat height,
    const GLint stacks,
    const GLint slices
) {
    assert( base > 0.0f );
    assert( height > 0.0f );
    assert( stacks > 0 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawCylinder( base, 0.0f, height, stacks, slices, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireCone(
    const GLfloat base,
    const GLfloat height,
    const GLint stacks,
    const GLint slices
) {
    assert( base > 0.0f );
    assert( height > 0.0f );
    assert( stacks > 0 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawCylinder( base, 0.0f, height, stacks, slices, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidCube(
    const GLfloat sideLength
) {
    drawSolidCubeIndexed(sideLength);
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidCubeTextured(
    const GLfloat sideLength
) {
    drawSolidCubeFlat(sideLength);
}
 
inline void CSCI441::drawSolidCubeIndexed(
    const GLfloat sideLength
) {
    assert( sideLength > 0.0f );
 
    CSCI441_INTERNAL::drawCube( sideLength, GL_FILL );
}
 
inline void CSCI441::drawSolidCubeFlat(
    const GLfloat sideLength
) {
    assert( sideLength > 0.0f );
 
    CSCI441_INTERNAL::drawCubeFlat( sideLength, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireCube(
    const GLfloat sideLength
) {
    assert( sideLength > 0.0f );
 
    CSCI441_INTERNAL::drawCube( sideLength, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawCubeMap(
    const GLfloat sideLength
) {
    assert(sideLength > 0.0f);
 
    CSCI441_INTERNAL::drawCube( sideLength, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidCylinder(
    const GLfloat base,
    const GLfloat top,
    const GLfloat height,
    const GLint stacks,
    const GLint slices
) {
    assert( (base >= 0.0f && top > 0.0f) || (base > 0.0f && top >= 0.0f) );
    assert( height > 0.0f );
    assert( stacks > 0 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawCylinder( base, top, height, stacks, slices, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireCylinder(
    const GLfloat base,
    const GLfloat top,
    const GLfloat height,
    const GLint stacks,
    const GLint slices
) {
    assert( (base >= 0.0f && top > 0.0f) || (base > 0.0f && top >= 0.0f) );
    assert( height > 0.0f );
    assert( stacks > 0 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawCylinder( base, top, height, stacks, slices, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidDisk(
    const GLfloat inner,
    const GLfloat outer,
    const GLint slices,
    const GLint rings
) {
    assert( inner >= 0.0f );
    assert( outer > 0.0f );
    assert( outer > inner );
    assert( slices > 2 );
    assert( rings > 0 );
 
    CSCI441_INTERNAL::drawPartialDisk( inner, outer, slices, rings, 0, glm::two_pi<GLfloat>(), GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireDisk(
    const GLfloat inner,
    const GLfloat outer,
    const GLint slices,
    const GLint rings
) {
    assert( inner >= 0.0f );
    assert( outer > 0.0f );
    assert( outer > inner );
    assert( slices > 2 );
    assert( rings > 0 );
 
    CSCI441_INTERNAL::drawPartialDisk( inner, outer, slices, rings, 0, glm::two_pi<GLfloat>(), GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidPartialDisk(
    const GLfloat inner,
    const GLfloat outer,
    const GLint slices,
    const GLint rings,
    const GLfloat start,
    const GLfloat sweep
) {
    assert( inner >= 0.0f );
    assert( outer > 0.0f );
    assert( outer > inner );
    assert( slices > 2 );
    assert( rings > 0 );
    assert( start >= 0.0f && start <= 360.0f );
    assert( sweep >= 0.0f && sweep <= 360.0f );
 
    CSCI441_INTERNAL::drawPartialDisk( inner, outer, slices, rings, start * glm::pi<float>() / 180.0f, sweep * glm::pi<float>() / 180.0f, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWirePartialDisk(
    const GLfloat inner,
    const GLfloat outer,
    const GLint slices,
    const GLint rings,
    const GLfloat start,
    const GLfloat sweep
) {
    assert( inner >= 0.0f );
    assert( outer > 0.0f );
    assert( outer > inner );
    assert( slices > 2 );
    assert( rings > 0 );
    assert( start >= 0.0f && start <= 360.0f );
    assert( sweep >= 0.0f && sweep <= 360.0f );
 
    CSCI441_INTERNAL::drawPartialDisk( inner, outer, slices, rings, start * glm::pi<float>() / 180.0f, sweep * glm::pi<float>() / 180.0f, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidSphere(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawSphere( radius, stacks, slices, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireSphere(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1);
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawSphere( radius, stacks, slices, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidHalfSphere(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawHalfSphere( radius, stacks, slices, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireHalfSphere(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1);
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawHalfSphere( radius, stacks, slices, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidDome(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1 );
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawDome( radius, stacks, slices, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireDome(
    const GLfloat radius,
    const GLint stacks,
    const GLint slices
) {
    assert( radius > 0.0f );
    assert( stacks > 1);
    assert( slices > 2 );
 
    CSCI441_INTERNAL::drawDome( radius, stacks, slices, GL_LINE );
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidTeapot(
    [[maybe_unused]] const GLfloat unused
) {
    CSCI441_INTERNAL::drawTeapot(GL_FILL);
}
 
[[maybe_unused]]
inline void CSCI441::drawWireTeapot(
    [[maybe_unused]] const GLfloat unused
) {
    CSCI441_INTERNAL::drawTeapot(GL_LINE);
}
 
[[maybe_unused]]
inline void CSCI441::drawSolidTorus(
    const GLfloat innerRadius,
    const GLfloat outerRadius,
    const GLint sides,
    const GLint rings
) {
    assert( innerRadius > 0.0f );
    assert( outerRadius > 0.0f );
    assert( sides > 2 );
    assert( rings > 2 );
 
    CSCI441_INTERNAL::drawTorus( innerRadius, outerRadius, sides, rings, GL_FILL );
}
 
[[maybe_unused]]
inline void CSCI441::drawWireTorus(
    const GLfloat innerRadius,
    const GLfloat outerRadius,
    const GLint sides,
    const GLint rings
) {
    assert( innerRadius > 0.0f );
    assert( outerRadius > 0.0f );
    assert( sides > 2 );
    assert( rings > 2 );
 
    CSCI441_INTERNAL::drawTorus( innerRadius, outerRadius, sides, rings, GL_LINE );
}
 
#endif // __CSCI441_OBJECTS_HPP__