X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcore%2Fsampler.h;fp=source%2Fcore%2Fsampler.h;h=e1e9bec5d60332e5331cd6e1e52e421c5256e8e9;hb=7aaec9a70b8d7733429bec043f8e33e02956f266;hp=0000000000000000000000000000000000000000;hpb=bec07999d95b76f4b47cffcc564d0cd0afc0435e;p=libs%2Fgl.git

diff --git a/source/core/sampler.h b/source/core/sampler.h
new file mode 100644
index 00000000..e1e9bec5
--- /dev/null
+++ b/source/core/sampler.h
@@ -0,0 +1,168 @@
+#ifndef MSP_GL_SAMPLER_H_
+#define MSP_GL_SAMPLER_H_
+
+#include <msp/datafile/objectloader.h>
+#include "gl.h"
+#include "predicate.h"
+
+namespace Msp {
+namespace GL {
+
+enum TextureFilter
+{
+	/// No filtering
+	NEAREST = GL_NEAREST,
+
+	/// Bilinear filtering
+	LINEAR = GL_LINEAR,
+
+	/// Mipmapping without filtering
+	NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
+
+	/// Linear filtering between two mipmap levels
+	NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
+
+	/// Bilinear filtering on the closest mipmap level
+	LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
+
+	/// Trilinear filtering between two mipmap levels
+	LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
+};
+
+
+enum TextureWrap
+{
+	/// Tile the texture infinitely
+	REPEAT = GL_REPEAT,
+
+	/// Extend the texels at the edge of the texture to infinity
+	CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
+
+	/// Tile the texture, with every other repetition mirrored
+	MIRRORED_REPEAT = GL_MIRRORED_REPEAT
+};
+
+class Texture;
+
+
+/**
+Samplers are used to access texture data in shaders.  To use a sampler with a
+texture, bind it to the same texture unit.  Each texture has a default sampler
+which is used if no external sampler is bound.
+
+A texture is generally rendered at a size that's either smaller or larger than
+its native size, so that the texture coordinates do not exactly correspond to
+the texels of the texture.  The kind of filtering used, if any, is determined
+by the minification and magnification filter parameters.  The default is LINEAR
+for magnification and NEAREST_MIPMAP_LINEAR for minification.
+
+If texture coordinates fall outside of the principal range of the texture,
+wrapping is applied.  The default for all directions is REPEAT.
+*/
+class Sampler
+{
+public:
+	class Loader: public DataFile::ObjectLoader<Sampler>
+	{
+	public:
+		Loader(Sampler &);
+	private:
+		void init();
+
+		void filter(TextureFilter);
+		void mag_filter(TextureFilter);
+		void max_anisotropy(float);
+		void min_filter(TextureFilter);
+		void wrap(TextureWrap);
+		void wrap_r(TextureWrap);
+		void wrap_s(TextureWrap);
+		void wrap_t(TextureWrap);
+	};
+
+private:
+	enum ParameterMask
+	{
+		MIN_FILTER = 1,
+		MAG_FILTER = 2,
+		MAX_ANISOTROPY = 4,
+		WRAP_S = 8,
+		WRAP_T = 16,
+		WRAP_R = 32,
+		COMPARE = 64
+	};
+
+	unsigned id;
+	const Texture *owner;
+	TextureFilter min_filter;
+	TextureFilter mag_filter;
+	float max_anisotropy;
+	TextureWrap wrap_s;
+	TextureWrap wrap_t;
+	TextureWrap wrap_r;
+	bool compare;
+	Predicate cmp_func;
+	mutable int dirty_params;
+
+public:
+	Sampler();
+	Sampler(const Texture &);
+private:
+	void init();
+
+	void update_parameter(int) const;
+	void set_parameter_i(unsigned, int) const;
+	void set_parameter_f(unsigned, float) const;
+
+public:
+	void set_min_filter(TextureFilter);
+	void set_mag_filter(TextureFilter);
+
+	/** Sets filter for both minification and magnification.  If a mipmapping
+	filter is specified, LINEAR is used for magnification. */
+	void set_filter(TextureFilter);
+
+	TextureFilter get_min_filter() const { return min_filter; }
+	TextureFilter get_mag_filter() const { return mag_filter; }
+
+	void set_max_anisotropy(float);
+	float get_max_anisotropy() const { return max_anisotropy; }
+
+	/** Sets the wrapping mode for all coordinates. */
+	void set_wrap(TextureWrap);
+
+	void set_wrap_s(TextureWrap);
+	void set_wrap_t(TextureWrap);
+	void set_wrap_r(TextureWrap);
+
+	/** Disables depth comparison. */
+	void disable_compare();
+
+	/** Enables depth comparison and sets the compare function.  Only has an
+	effect when used with a depth texture.  When depth comparison is enabled,
+	the third component of the texture coordinate is compared against the texel
+	value, and the result is returned as the texture sample.*/
+	void set_compare(Predicate);
+
+	bool is_compare_enabled() const { return compare; }
+	Predicate get_compare_function() const { return cmp_func; }
+
+	void bind() const { bind_to(0); }
+	void bind_to(unsigned) const;
+
+	static const Sampler *current(unsigned = 0);
+	static void unbind() { unbind_from(0); }
+	static void unbind_from(unsigned);
+
+	void unload();
+};
+
+
+bool is_mipmapped(TextureFilter);
+
+void operator>>(const LexicalConverter &, TextureFilter &);
+void operator>>(const LexicalConverter &, TextureWrap &);
+
+} // namespace GL
+} // namespace Msp
+
+#endif