source/src/engine/gl/sampler.cpp

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <engine/gl/sampler.hpp>
#include <glad/gl.h>

namespace gl {

namespace
{
	static constexpr GLenum mag_filter_lut[] =
	{
		GL_NEAREST, // sampler_filter::nearest
		GL_LINEAR   // sampler_filter::linear
	};
	
	static constexpr GLenum min_filter_lut[][2] =
	{
		{
			GL_NEAREST_MIPMAP_NEAREST, // sampler_filter::nearest, sampler_mipmap_mode::nearest
			GL_NEAREST_MIPMAP_LINEAR   // sampler_filter::nearest, sampler_mipmap_mode::linear
		},
		{
			GL_LINEAR_MIPMAP_NEAREST, // sampler_filter::linear, sampler_mipmap_mode::nearest
			GL_LINEAR_MIPMAP_LINEAR   // sampler_filter::linear, sampler_mipmap_mode::linear
		},
	};
	
	static constexpr GLenum wrap_lut[] =
	{
		GL_REPEAT,              // sampler_address_mode::repeat
		GL_MIRRORED_REPEAT,     // sampler_address_mode::mirrored_repeat
		GL_CLAMP_TO_EDGE,       // sampler_address_mode::clamp_to_edge
		GL_CLAMP_TO_BORDER,     // sampler_address_mode::clamp_to_border
		GL_MIRROR_CLAMP_TO_EDGE // sampler_address_mode::mirror_clamp_to_edge
	};
	
	static constexpr GLenum compare_func_lut[] =
	{
		GL_NEVER,    // compare_op::never
		GL_LESS,     // compare_op::less
		GL_EQUAL,    // compare_op::equal
		GL_LEQUAL,   // compare_op::less_or_equal
		GL_GREATER,  // compare_op::greater
		GL_NOTEQUAL, // compare_op::not_equal
		GL_GEQUAL,   // compare_op::greater_or_equal
		GL_ALWAYS    // compare_op::always
	};
}

sampler::sampler
(
	sampler_filter mag_filter,
	sampler_filter min_filter,
	sampler_mipmap_mode mipmap_mode,
	sampler_address_mode address_mode_u,
	sampler_address_mode address_mode_v,
	sampler_address_mode address_mode_w,
	float mip_lod_bias,
	float max_anisotropy,
	bool compare_enabled,
	gl::compare_op compare_op,
	float min_lod,
	float max_lod,
	const std::array<float, 4>& border_color
)
{
	glCreateSamplers(1, &m_gl_named_sampler);
	
	set_mag_filter(mag_filter);
	set_min_filter(min_filter);
	set_mipmap_mode(mipmap_mode);
	set_address_mode_u(address_mode_u);
	set_address_mode_v(address_mode_v);
	set_address_mode_w(address_mode_w);
	set_mip_lod_bias(mip_lod_bias);
	set_max_anisotropy(max_anisotropy);
	set_compare_enabled(compare_enabled);
	set_compare_op(compare_op);
	set_min_lod(min_lod);
	set_max_lod(max_lod);
	set_border_color(border_color);
}

sampler::~sampler()
{
	glDeleteSamplers(1, &m_gl_named_sampler);
}

void sampler::set_mag_filter(sampler_filter filter)
{
	if (m_mag_filter != filter)
	{
		m_mag_filter = filter;
		const auto gl_mag_filter = mag_filter_lut[std::to_underlying(m_mag_filter)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_MAG_FILTER, gl_mag_filter);
	}
}

void sampler::set_min_filter(sampler_filter filter)
{
	if (m_min_filter != filter)
	{
		m_min_filter = filter;
		const auto gl_min_filter = min_filter_lut[std::to_underlying(m_min_filter)][std::to_underlying(m_mipmap_mode)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_MIN_FILTER, gl_min_filter);
	}
}

void sampler::set_mipmap_mode(sampler_mipmap_mode mode)
{
	if (m_mipmap_mode != mode)
	{
		m_mipmap_mode = mode;
		const auto gl_min_filter = min_filter_lut[std::to_underlying(m_min_filter)][std::to_underlying(m_mipmap_mode)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_MIN_FILTER, gl_min_filter);
	}
}

void sampler::set_address_mode_u(sampler_address_mode mode)
{
	if (m_address_mode_u != mode)
	{
		m_address_mode_u = mode;
		const auto gl_wrap_s = wrap_lut[std::to_underlying(m_address_mode_u)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_WRAP_S, gl_wrap_s);
	}
}

void sampler::set_address_mode_v(sampler_address_mode mode)
{
	if (m_address_mode_v != mode)
	{
		m_address_mode_v = mode;
		const auto gl_wrap_t = wrap_lut[std::to_underlying(m_address_mode_v)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_WRAP_T, gl_wrap_t);
	}
}

void sampler::set_address_mode_w(sampler_address_mode mode)
{
	if (m_address_mode_w != mode)
	{
		m_address_mode_w = mode;
		const auto gl_wrap_r = wrap_lut[std::to_underlying(m_address_mode_w)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_WRAP_R, gl_wrap_r);
	}
}

void sampler::set_mip_lod_bias(float bias)
{
	if (m_mip_lod_bias != bias)
	{
		m_mip_lod_bias = bias;
		glSamplerParameterf(m_gl_named_sampler, GL_TEXTURE_LOD_BIAS, m_mip_lod_bias);
	}
}

void sampler::set_max_anisotropy(float anisotropy)
{
	if (m_max_anisotropy != anisotropy)
	{
		m_max_anisotropy = anisotropy;
		glSamplerParameterf(m_gl_named_sampler, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_max_anisotropy);
	}
}

void sampler::set_compare_enabled(bool enabled)
{
	if (m_compare_enabled != enabled)
	{
		m_compare_enabled = enabled;
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_COMPARE_MODE, (m_compare_enabled) ? GL_COMPARE_REF_TO_TEXTURE : GL_NONE);
	}
}

void sampler::set_compare_op(gl::compare_op op)
{
	if (m_compare_op != op)
	{
		m_compare_op = op;
		const auto gl_compare_func = compare_func_lut[std::to_underlying(m_compare_op)];
		glSamplerParameteri(m_gl_named_sampler, GL_TEXTURE_COMPARE_FUNC, gl_compare_func);
	}
}

void sampler::set_min_lod(float lod)
{
	if (m_min_lod != lod)
	{
		m_min_lod = lod;
		glSamplerParameterf(m_gl_named_sampler, GL_TEXTURE_MIN_LOD, m_min_lod);
	}
}

void sampler::set_max_lod(float lod)
{
	if (m_max_lod != lod)
	{
		m_max_lod = lod;
		glSamplerParameterf(m_gl_named_sampler, GL_TEXTURE_MAX_LOD, m_max_lod);
	}
}

void sampler::set_border_color(const std::array<float, 4>& color)
{
	if (m_border_color != color)
	{
		m_border_color = color;
		glSamplerParameterfv(m_gl_named_sampler, GL_TEXTURE_BORDER_COLOR, m_border_color.data());
	}
}

} // namespace gl