diff --git a/src/Magnum.h b/src/Magnum.h index a0e6e96f3..8ee5994f1 100644 --- a/src/Magnum.h +++ b/src/Magnum.h @@ -22,9 +22,13 @@ #include #include "Math/Matrix4.h" +#include "Math/Vector2.h" namespace Magnum { +/** @brief Two-component floating-point vector */ +typedef Math::Vector2 Vector2; + /** @brief Three-component floating-point vector */ typedef Math::Vector3 Vector3; diff --git a/src/Math/Vector2.h b/src/Math/Vector2.h new file mode 100644 index 000000000..38c64337a --- /dev/null +++ b/src/Math/Vector2.h @@ -0,0 +1,77 @@ +#ifndef Magnum_Math_Vector2_h +#define Magnum_Math_Vector2_h +/* + Copyright © 2010 Vladimír Vondruš + + This file is part of Magnum. + + Magnum is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 2 + only, as published by the Free Software Foundation. + + Magnum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 2 for more details. +*/ + +/** @file + * @brief Class Magnum::Math::Vector2 + */ + +#include "Vector.h" + +namespace Magnum { namespace Math { + +/** @brief Vector (three-component) */ +template class Vector2: public Vector { + public: + /** @copydoc Vector::Vector */ + inline Vector2() {} + + /** @copydoc Vector::Vector(const T*) */ + inline Vector2(const T* data): Vector(data) {} + + /** @copydoc Vector::Vector(const Vector&) */ + inline Vector2(const Vector& other): Vector(other) {} + + /** + * @brief Constructor + * @param x X value + * @param y Y value + */ + inline Vector2(T x, T y) { + setX(x); setY(y); + } + + inline T x() const { return Vector::at(0); } /**< @brief X component */ + inline T y() const { return Vector::at(1); } /**< @brief Y component */ + + inline void setX(T value) { set(0, value); } /**< @brief Set X component */ + inline void setY(T value) { set(1, value); } /**< @brief Set Y component */ + + /** @copydoc Vector::operator=() */ + inline Vector2& operator=(const Vector& other) { return Vector::operator=(other); } + + /** @copydoc Vector::operator*(T) */ + inline Vector2 operator*(T number) const { return Vector::operator*(number); } + + /** @copydoc Vector::operator/() */ + inline Vector2 operator/(T number) const { return Vector::operator/(number); } + + /** @copydoc Vector::operator+() */ + inline Vector2 operator+(const Vector& other) const { return Vector::operator+(other); } + + /** @copydoc Vector::operator-(const Vector&) */ + inline Vector2 operator-(const Vector& other) const { return Vector::operator-(other); } + + /** @copydoc Vector::operator-() */ + inline Vector2 operator-() const { return Vector::operator-(); } + + /** @copydoc Vector::normalized() */ + inline Vector2 normalized() const { return Vector::normalized(); } +}; + +}} + +#endif diff --git a/src/Mesh.h b/src/Mesh.h index 0939454ea..40be35942 100644 --- a/src/Mesh.h +++ b/src/Mesh.h @@ -210,6 +210,10 @@ template<> inline void Mesh::bindAttribute(Buffer* buffer, GLuint attr bindAttribute(buffer, attribute, 1, GL_DOUBLE); } +template<> inline void Mesh::bindAttribute(Buffer* buffer, GLuint attribute) { + bindAttribute(buffer, attribute, 2, GL_FLOAT); +} + template<> inline void Mesh::bindAttribute(Buffer* buffer, GLuint attribute) { bindAttribute(buffer, attribute, 3, GL_FLOAT); } diff --git a/src/Texture.h b/src/Texture.h new file mode 100644 index 000000000..8800994cc --- /dev/null +++ b/src/Texture.h @@ -0,0 +1,276 @@ +#ifndef Magnum_Texture_h +#define Magnum_Texture_h +/* + Copyright © 2010 Vladimír Vondruš + + This file is part of Magnum. + + Magnum is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License version 3 + only, as published by the Free Software Foundation. + + Magnum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License version 3 for more details. +*/ + +/** @file + * @brief Class Magnum::Texture + */ + +#include "Magnum.h" + +namespace Magnum { + +/** + * @brief Texture + * + * Template class for one- to three-dimensional textures. Recommended usage is + * via subclassing and setting texture data from e.g. constructor with + * setData(). + */ +template class Texture { + public: + /** @brief Texture filtering */ + enum Filter { + /** + * Nearest neighbor filtering + */ + NearestNeighbor = GL_NEAREST, + + /** + * Linear filtering + */ + Linear = GL_LINEAR + }; + + /** @brief Mip level selection */ + enum Mipmap { + /** + * Select base mipmap level. + */ + BaseLevel = 0, + + /** + * Select nearest mip level. + */ + NearestLevel = 0x100, + + /** + * Linear interpolation of nearest mip levels. + */ + LinearInterpolation = 0x102 + }; + + /** @brief Texture wrapping on the edge */ + enum Wrapping { + /** + * Repeat texture + */ + Repeat = GL_REPEAT, + + /** + * Repeat mirrored texture + */ + MirroredRepeat = GL_MIRRORED_REPEAT, + + /** + * Clamp to edge. Coordinates out of the range will be clamped to + * first / last column / row in given direction. + */ + ClampToEdge = GL_CLAMP_TO_EDGE, + + /** + * Clamp to border color. Coordinates out of range will be clamped + * to border color (set with setBorderColor()). + */ + ClampToBorder = GL_CLAMP_TO_BORDER + }; + + /** @brief Internal format */ + enum InternalFormat { + CompressedRed = GL_COMPRESSED_RED, + CompressedRedGreen = GL_COMPRESSED_RG, + CompressedRGB = GL_COMPRESSED_RGB, + CompressedRGBA = GL_COMPRESSED_RGBA + }; + + /** @brief Color format */ + enum ColorFormat { + Red = GL_RED, + RedGreen = GL_RG, + RGB = GL_RGB, + RGBA = GL_RGBA, + BGR = GL_BGR, + BGRA = GL_BGRA + }; + + /** + * @brief Constructor + * + * Creates one OpenGL texture. + */ + inline Texture(): target(GL_TEXTURE_1D + dimensions - 1) { + glGenTextures(1, &texture); + } + + /** + * @brief Destructor + * + * Deletes assigned OpenGL texture. + */ + inline virtual ~Texture() { + glDeleteTextures(1, &texture); + } + + /** @brief Bind texture for usage / rendering */ + inline void bind() const { + glBindTexture(dimensions, texture); + } + + /** + * @brief Unbind texture + * + * @note Unbinds any texture from given dimension, not only this + * particular one. + */ + inline void unbind() const { + glBindTexture(dimensions, texture); + } + + /** + * @brief Set minification filter + * @param filter Filter + * @param mipmap Mipmap filtering. If set to anything else than + * BaseLevel, make sure textures for all mip levels are set or call + * generateMipmap(). + * + * Sets filter used when the object pixel size is smaller than the + * texture size. + */ + inline void setMinificationFilter(Filter filter, Mipmap mipmap = BaseLevel) { + bind(); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter|mipmap); + unbind(); + } + + /** + * @brief Set magnification filter + * @param filter Filter + * + * Sets filter used when the object pixel size is larger than largest + * texture size. + */ + inline void setMagnificationFilter(Filter filter) { + bind(); + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter); + unbind(); + } + + /** + * @brief Set wrapping + * @param wrapping Wrapping type for all texture dimensions + * + * Sets wrapping type for coordinates out of range (-1, 1). + */ + void setWrapping(const Math::Vector& wrapping) { + bind(); + for(int i = 0; i != dimensions; ++i) switch(i) { + case 0: + glTexParameteri(target, GL_TEXTURE_WRAP_S, wrapping.at(i)); + break; + case 1: + glTexParameteri(target, GL_TEXTURE_WRAP_T, wrapping.at(i)); + break; + case 2: + glTexParameteri(target, GL_TEXTURE_WRAP_R, wrapping.at(i)); + break; + } + unbind(); + } + + /** + * @brief Generate mipmap + * + * @see setMinificationFilter() + */ + void generateMipmap() { + bind(); + glGenerateMipmap(target); + unbind(); + } + + protected: + /** + * @brief Set texture data + * @param mipLevel Mip level + * @param internalFormat Internal texture format. One value from + * InternalFormat or ColorFormat enum. + * @param _dimensions Texture dimensions + * @param colorFormat Color format of passed data. Data size per + * color channel is detected from format of passed data array. + * @param data Texture data. + */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLubyte* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_UNSIGNED_BYTE, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLbyte* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_BYTE, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLushort* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_UNSIGNED_SHORT, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLshort* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_SHORT, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLuint* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_UNSIGNED_INT, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLint* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_INT, data); + } + + /** @copydoc setData() */ + inline void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, const GLfloat* data) { + setData(mipLevel, internalFormat, _dimensions, colorFormat, GL_FLOAT, data); + } + + private: + GLuint texture; + const GLenum target; + + void setData(GLint mipLevel, int internalFormat, const Math::Vector& _dimensions, ColorFormat colorFormat, GLenum pixelFormat, const GLvoid* data) { + bind(); + if(dimensions == 1) + glTexImage1D(target, mipLevel, internalFormat, _dimensions.at(0), 0, colorFormat, pixelFormat, data); + else if(dimensions == 2) + glTexImage2D(target, mipLevel, internalFormat, _dimensions.at(0), _dimensions.at(1), 0, colorFormat, pixelFormat, data); + else if(dimensions == 3) + glTexImage3D(target, mipLevel, internalFormat, _dimensions.at(0), _dimensions.at(1), _dimensions.at(2), 0, colorFormat, pixelFormat, data); + unbind(); + } +}; + +/** @brief One-dimensional texture */ +typedef Texture<1> Texture1D; + +/** @brief Two-dimensional texture */ +typedef Texture<2> Texture2D; + +/** @brief Three-dimensional texture */ +typedef Texture<3> Texture3D; + +} + +#endif