16969175463

Committed 14 Aug 2025 08:25AM UTC coverage: 74.293% (-0.3%) from 74.615%

Build # 16969175463

Build Type

push

github

Committed by

Razakhel

Commit Message

[Render/Renderer] Added sampler functions

- Renamed activateTexture() to setActiveTexture(), and TextureParam* enums to TextureParameter*

- Added several noexcept specifications

- Removed single dots at the end of message strings

Coverage Stats

66 of 170 new or added lines in 28 files covered. (38.82%)

8326 of 11207 relevant lines covered (74.29%)

1746.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.87

/src/RaZ/Data/Image.cpp

#include "RaZ/Data/Image.hpp"

#include <stdexcept>

namespace Raz {

bool ImageDataB::operator==(const ImageData& imgData) const {
  assert("Error: Image data equality check requires having data of the same type." && imgData.getDataType() == ImageDataType::BYTE);

  const auto& imgDataB = static_cast<const ImageDataB&>(imgData);

  if (data.size() != imgDataB.data.size())
    return false;

  return std::equal(data.cbegin(), data.cend(), imgDataB.data.cbegin());
}

bool ImageDataF::operator==(const ImageData& imgData) const {
  assert("Error: Image data equality check requires having data of the same type." && imgData.getDataType() == ImageDataType::FLOAT);

  const auto& imgDataF = static_cast<const ImageDataF&>(imgData);

  if (data.size() != imgDataF.data.size())
    return false;

  return std::equal(data.cbegin(), data.cend(), imgDataF.data.cbegin());
}

Image::Image(ImageColorspace colorspace, ImageDataType dataType) : m_colorspace{ colorspace }, m_dataType{ dataType } {
  assert("Error: An sRGB(A) image must have a byte data type."
      && (m_colorspace != ImageColorspace::SRGB || m_colorspace != ImageColorspace::SRGBA || m_dataType == ImageDataType::BYTE));

  switch (colorspace) {
    case ImageColorspace::GRAY:
      m_channelCount = 1;
      break;

    case ImageColorspace::GRAY_ALPHA:
      m_channelCount = 2;
      break;

    case ImageColorspace::RGB:
    case ImageColorspace::SRGB:
      m_channelCount = 3;
      break;

    case ImageColorspace::RGBA:
    case ImageColorspace::SRGBA:
      m_channelCount = 4;
      break;

    default:
      throw std::invalid_argument("[Image] Invalid colorspace to create an image with");
  }
}

Image::Image(unsigned int width, unsigned int height, ImageColorspace colorspace, ImageDataType dataType) : Image(colorspace, dataType) {
  m_width  = width;
  m_height = height;

  const std::size_t imgDataSize = m_width * m_height * m_channelCount;

  if (m_dataType == ImageDataType::FLOAT)
    m_data = ImageDataF::create(imgDataSize);
  else
    m_data = ImageDataB::create(imgDataSize);
}

Image::Image(const Image& img) : m_width{ img.m_width },
                                 m_height{ img.m_height },
                                 m_colorspace{ img.m_colorspace },
                                 m_dataType{ img.m_dataType },
                                 m_channelCount{ img.m_channelCount } {
  if (img.m_data == nullptr)
    return;

  switch (img.m_dataType) {
    case ImageDataType::BYTE:
      m_data = ImageDataB::create(*static_cast<ImageDataB*>(img.m_data.get()));
      break;

    case ImageDataType::FLOAT:
      m_data = ImageDataF::create(*static_cast<ImageDataF*>(img.m_data.get()));
      break;

    default:
      throw std::invalid_argument("[Image] Invalid data type");
  }
}

uint8_t Image::recoverByteValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex) const {
  assert("Error: Getting a byte value requires the image to be of a byte type." && m_dataType == ImageDataType::BYTE);
  return recoverValue<uint8_t>(widthIndex, heightIndex, channelIndex);
}

float Image::recoverFloatValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex) const {
  assert("Error: Getting a float value requires the image to be of a float type." && m_dataType == ImageDataType::FLOAT);
  return recoverValue<float>(widthIndex, heightIndex, channelIndex);
}

void Image::setByteValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex, uint8_t val) {
  assert("Error: Setting a byte value requires the image to be of a byte type." && m_dataType == ImageDataType::BYTE);
  setValue(widthIndex, heightIndex, channelIndex, val);
}

void Image::setFloatValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex, float val) {
  assert("Error: Setting a float value requires the image to be of a float type." && m_dataType == ImageDataType::FLOAT);
  setValue(widthIndex, heightIndex, channelIndex, val);
}

Image& Image::operator=(const Image& img) {
  m_width        = img.m_width;
  m_height       = img.m_height;
  m_colorspace   = img.m_colorspace;
  m_dataType     = img.m_dataType;
  m_channelCount = img.m_channelCount;

  if (img.m_data) {
    switch (img.m_dataType) {
      case ImageDataType::BYTE:
        m_data = ImageDataB::create(*static_cast<ImageDataB*>(img.m_data.get()));
        break;

      case ImageDataType::FLOAT:
        m_data = ImageDataF::create(*static_cast<ImageDataF*>(img.m_data.get()));
        break;

      default:
        throw std::invalid_argument("[Image] Invalid data type");
    }
  } else {
    m_data.reset();
  }

  return *this;
}

bool Image::operator==(const Image& img) const {
  if (m_width != img.m_width || m_height != img.m_height || m_channelCount != img.m_channelCount || m_colorspace != img.m_colorspace
      || m_dataType != img.m_dataType || m_data == nullptr || img.m_data == nullptr)
    return false;

  return (*m_data == *img.m_data);
}

} // namespace Raz

1	#include "RaZ/Data/Image.hpp"
2
3	#include <stdexcept>
4
5	namespace Raz {
6
7	bool ImageDataB::operator==(const ImageData& imgData) const {	8✔
8	assert("Error: Image data equality check requires having data of the same type." && imgData.getDataType() == ImageDataType::BYTE);	8✔
9
10	const auto& imgDataB = static_cast<const ImageDataB&>(imgData);	8✔
11
12	if (data.size() != imgDataB.data.size())	8✔
13	return false;	×
14
15	return std::equal(data.cbegin(), data.cend(), imgDataB.data.cbegin());	8✔
16	}
17
18	bool ImageDataF::operator==(const ImageData& imgData) const {	3✔
19	assert("Error: Image data equality check requires having data of the same type." && imgData.getDataType() == ImageDataType::FLOAT);	3✔
20
21	const auto& imgDataF = static_cast<const ImageDataF&>(imgData);	3✔
22
23	if (data.size() != imgDataF.data.size())	3✔
24	return false;	×
25
26	return std::equal(data.cbegin(), data.cend(), imgDataF.data.cbegin());	3✔
27	}
28
29	Image::Image(ImageColorspace colorspace, ImageDataType dataType) : m_colorspace{ colorspace }, m_dataType{ dataType } {	275✔
30	assert("Error: An sRGB(A) image must have a byte data type."	275✔
31	&& (m_colorspace != ImageColorspace::SRGB \|\| m_colorspace != ImageColorspace::SRGBA \|\| m_dataType == ImageDataType::BYTE));
32
33	switch (colorspace) {	275✔
34	case ImageColorspace::GRAY:	66✔
35	m_channelCount = 1;	66✔
36	break;	66✔
37
38	case ImageColorspace::GRAY_ALPHA:	7✔
39	m_channelCount = 2;	7✔
40	break;	7✔
41
42	case ImageColorspace::RGB:	154✔
43	case ImageColorspace::SRGB:
44	m_channelCount = 3;	154✔
45	break;	154✔
46
47	case ImageColorspace::RGBA:	48✔
48	case ImageColorspace::SRGBA:
49	m_channelCount = 4;	48✔
50	break;	48✔
51
52	default:	×
NEW 53	throw std::invalid_argument("[Image] Invalid colorspace to create an image with");	×
54	}
55	}	275✔
56
57	Image::Image(unsigned int width, unsigned int height, ImageColorspace colorspace, ImageDataType dataType) : Image(colorspace, dataType) {	271✔
58	m_width = width;	271✔
59	m_height = height;	271✔
60
61	const std::size_t imgDataSize = m_width * m_height * m_channelCount;	271✔
62
63	if (m_dataType == ImageDataType::FLOAT)	271✔
64	m_data = ImageDataF::create(imgDataSize);	20✔
65	else
66	m_data = ImageDataB::create(imgDataSize);	251✔
67	}	271✔
68
69	Image::Image(const Image& img) : m_width{ img.m_width },	25✔
70	m_height{ img.m_height },	25✔
71	m_colorspace{ img.m_colorspace },	25✔
72	m_dataType{ img.m_dataType },	25✔
73	m_channelCount{ img.m_channelCount } {	25✔
74	if (img.m_data == nullptr)	25✔
75	return;	6✔
76
77	switch (img.m_dataType) {	19✔
78	case ImageDataType::BYTE:	15✔
79	m_data = ImageDataB::create(static_cast<ImageDataB>(img.m_data.get()));	15✔
80	break;	15✔
81
82	case ImageDataType::FLOAT:	4✔
83	m_data = ImageDataF::create(static_cast<ImageDataF>(img.m_data.get()));	4✔
84	break;	4✔
85
NEW 86	default:	×
NEW 87	throw std::invalid_argument("[Image] Invalid data type");	×
88	}
89	}	×
90
91	uint8_t Image::recoverByteValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex) const {	647✔
92	assert("Error: Getting a byte value requires the image to be of a byte type." && m_dataType == ImageDataType::BYTE);	647✔
93	return recoverValue<uint8_t>(widthIndex, heightIndex, channelIndex);	647✔
94	}
95
96	float Image::recoverFloatValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex) const {	19✔
97	assert("Error: Getting a float value requires the image to be of a float type." && m_dataType == ImageDataType::FLOAT);	19✔
98	return recoverValue<float>(widthIndex, heightIndex, channelIndex);	19✔
99	}
100
101	void Image::setByteValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex, uint8_t val) {	84✔
102	assert("Error: Setting a byte value requires the image to be of a byte type." && m_dataType == ImageDataType::BYTE);	84✔
103	setValue(widthIndex, heightIndex, channelIndex, val);	84✔
104	}	84✔
105
106	void Image::setFloatValue(std::size_t widthIndex, std::size_t heightIndex, uint8_t channelIndex, float val) {	44✔
107	assert("Error: Setting a float value requires the image to be of a float type." && m_dataType == ImageDataType::FLOAT);	44✔
108	setValue(widthIndex, heightIndex, channelIndex, val);	44✔
109	}	44✔
110
111	Image& Image::operator=(const Image& img) {	1✔
112	m_width = img.m_width;	1✔
113	m_height = img.m_height;	1✔
114	m_colorspace = img.m_colorspace;	1✔
115	m_dataType = img.m_dataType;	1✔
116	m_channelCount = img.m_channelCount;	1✔
117
118	if (img.m_data) {	1✔
119	switch (img.m_dataType) {	1✔
120	case ImageDataType::BYTE:	1✔
121	m_data = ImageDataB::create(static_cast<ImageDataB>(img.m_data.get()));	1✔
122	break;	1✔
123
124	case ImageDataType::FLOAT:	×
125	m_data = ImageDataF::create(static_cast<ImageDataF>(img.m_data.get()));	×
126	break;	×
127
NEW 128	default:	×
NEW 129	throw std::invalid_argument("[Image] Invalid data type");	×
130	}
131	} else {
132	m_data.reset();	×
133	}
134
135	return *this;	1✔
136	}
137
138	bool Image::operator==(const Image& img) const {	19✔
139	if (m_width != img.m_width \|\| m_height != img.m_height \|\| m_channelCount != img.m_channelCount \|\| m_colorspace != img.m_colorspace	17✔
140	\|\| m_dataType != img.m_dataType \|\| m_data == nullptr \|\| img.m_data == nullptr)	36✔
141	return false;	8✔
142
143	return (m_data == img.m_data);	11✔
144	}
145
146	} // namespace Raz

Razakhel / RaZ / 16969175463

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous