minetest/irrlicht
1
0
Fork 0
mirror of https://github.com/minetest/irrlicht.git synced 2025-07-04 09:10:27 +02:00
Code Issues Projects Releases Wiki Activity

Reformat the code, using:

Browse Source 
find -type f |  # list all regular files
  grep -E '\.(h|cpp|mm)$' |  # filter for source files
  grep -v '/mt_' |  # filter out generated files
  grep -v '/vendor/' | # and vendored GL
  grep -v '/test/image_loader_test.cpp' |  # and this file (has giant literals arrays)
  xargs -n 1 -P $(nproc) clang-format -i  # reformat everything

Co-authored-by: numzero <numzer0@yandex.ru>
This commit is contained in:
Desour
2024-03-20 19:35:52 +01:00
committed by sfan5
parent 9814510b1b
commit f5c6d3e945
292 changed files with 37376 additions and 42421 deletions
Download Patch File Download Diff File Expand all files Collapse all files

279
source/Irrlicht/OpenGL/MaterialRenderer.cpp
View File

@ -20,22 +20,21 @@ namespace irr
namespace video
{
COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
IShaderConstantSetCallBack* callback,
COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase *driver,
s32 &outMaterialTypeNr,
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram,
IShaderConstantSetCallBack *callback,
E_MATERIAL_TYPE baseMaterial,
s32 userData)
: Driver(driver), CallBack(callback), Alpha(false), Blending(false), Program(0), UserData(userData)
s32 userData) :
Driver(driver),
CallBack(callback), Alpha(false), Blending(false), Program(0), UserData(userData)
{
#ifdef _DEBUG
setDebugName("MaterialRenderer");
#endif
switch (baseMaterial)
{
switch (baseMaterial) {
case EMT_TRANSPARENT_VERTEX_ALPHA:
case EMT_TRANSPARENT_ALPHA_CHANNEL:
Alpha = true;
@ -53,14 +52,13 @@ COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
init(outMaterialTypeNr, vertexShaderProgram, pixelShaderProgram);
}
COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
IShaderConstantSetCallBack* callback,
E_MATERIAL_TYPE baseMaterial, s32 userData)
: Driver(driver), CallBack(callback), Alpha(false), Blending(false), Program(0), UserData(userData)
COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase *driver,
IShaderConstantSetCallBack *callback,
E_MATERIAL_TYPE baseMaterial, s32 userData) :
Driver(driver),
CallBack(callback), Alpha(false), Blending(false), Program(0), UserData(userData)
{
switch (baseMaterial)
{
switch (baseMaterial) {
case EMT_TRANSPARENT_VERTEX_ALPHA:
case EMT_TRANSPARENT_ALPHA_CHANNEL:
Alpha = true;
@ -76,20 +74,18 @@ COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
CallBack->grab();
}
COpenGL3MaterialRenderer::~COpenGL3MaterialRenderer()
{
if (CallBack)
CallBack->drop();
if (Program)
{
if (Program) {
GLuint shaders[8];
GLint count;
GL.GetAttachedShaders(Program, 8, &count, shaders);
count=core::min_(count,8);
for (GLint i=0; i<count; ++i)
count = core::min_(count, 8);
for (GLint i = 0; i < count; ++i)
GL.DeleteShader(shaders[i]);
GL.DeleteProgram(Program);
Program = 0;
@ -103,9 +99,9 @@ GLuint COpenGL3MaterialRenderer::getProgram() const
return Program;
}
void COpenGL3MaterialRenderer::init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
void COpenGL3MaterialRenderer::init(s32 &outMaterialTypeNr,
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram,
bool addMaterial)
{
outMaterialTypeNr = -1;
@ -123,8 +119,8 @@ void COpenGL3MaterialRenderer::init(s32& outMaterialTypeNr,
if (!createShader(GL_FRAGMENT_SHADER, pixelShaderProgram))
return;
for ( size_t i = 0; i < EVA_COUNT; ++i )
GL.BindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i]);
for (size_t i = 0; i < EVA_COUNT; ++i)
GL.BindAttribLocation(Program, i, sBuiltInVertexAttributeNames[i]);
if (!linkProgram())
return;
@ -133,8 +129,7 @@ void COpenGL3MaterialRenderer::init(s32& outMaterialTypeNr,
outMaterialTypeNr = Driver->addMaterialRenderer(this);
}
bool COpenGL3MaterialRenderer::OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype)
bool COpenGL3MaterialRenderer::OnRender(IMaterialRendererServices *service, E_VERTEX_TYPE vtxtype)
{
if (CallBack && Program)
CallBack->OnSetConstants(this, UserData);
@ -142,32 +137,28 @@ bool COpenGL3MaterialRenderer::OnRender(IMaterialRendererServices* service, E_VE
return true;
}
void COpenGL3MaterialRenderer::OnSetMaterial(const video::SMaterial& material,
const video::SMaterial& lastMaterial,
bool resetAllRenderstates,
video::IMaterialRendererServices* services)
void COpenGL3MaterialRenderer::OnSetMaterial(const video::SMaterial &material,
const video::SMaterial &lastMaterial,
bool resetAllRenderstates,
video::IMaterialRendererServices *services)
{
COpenGL3CacheHandler* cacheHandler = Driver->getCacheHandler();
COpenGL3CacheHandler *cacheHandler = Driver->getCacheHandler();
cacheHandler->setProgram(Program);
Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
if (Alpha)
{
if (Alpha) {
cacheHandler->setBlend(true);
cacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else if (Blending)
{
E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;
} else if (Blending) {
E_BLEND_FACTOR srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact;
E_MODULATE_FUNC modulate;
u32 alphaSource;
unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);
cacheHandler->setBlendFuncSeparate(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact),
Driver->getGLBlend(srcAlphaFact), Driver->getGLBlend(dstAlphaFact));
Driver->getGLBlend(srcAlphaFact), Driver->getGLBlend(dstAlphaFact));
cacheHandler->setBlend(true);
}
@ -176,28 +167,23 @@ void COpenGL3MaterialRenderer::OnSetMaterial(const video::SMaterial& material,
CallBack->OnSetMaterial(material);
}
void COpenGL3MaterialRenderer::OnUnsetMaterial()
{
}
bool COpenGL3MaterialRenderer::isTransparent() const
{
return (Alpha || Blending);
}
s32 COpenGL3MaterialRenderer::getRenderCapability() const
{
return 0;
}
bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char* shader)
bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char *shader)
{
if (Program)
{
if (Program) {
GLuint shaderHandle = GL.CreateShader(shaderType);
GL.ShaderSource(shaderHandle, 1, &shader, NULL);
GL.CompileShader(shaderHandle);
@ -206,22 +192,20 @@ bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char* shade
GL.GetShaderiv(shaderHandle, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
{
if (status != GL_TRUE) {
os::Printer::log("GLSL shader failed to compile", ELL_ERROR);
GLint maxLength=0;
GLint maxLength = 0;
GLint length;
GL.GetShaderiv(shaderHandle, GL_INFO_LOG_LENGTH,
&maxLength);
if (maxLength)
{
if (maxLength) {
GLchar *infoLog = new GLchar[maxLength];
GL.GetShaderInfoLog(shaderHandle, maxLength, &length, infoLog);
os::Printer::log(reinterpret_cast<const c8*>(infoLog), ELL_ERROR);
delete [] infoLog;
os::Printer::log(reinterpret_cast<const c8 *>(infoLog), ELL_ERROR);
delete[] infoLog;
}
return false;
@ -233,32 +217,28 @@ bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char* shade
return true;
}
bool COpenGL3MaterialRenderer::linkProgram()
{
if (Program)
{
if (Program) {
GL.LinkProgram(Program);
GLint status = 0;
GL.GetProgramiv(Program, GL_LINK_STATUS, &status);
if (!status)
{
if (!status) {
os::Printer::log("GLSL shader program failed to link", ELL_ERROR);
GLint maxLength=0;
GLint maxLength = 0;
GLsizei length;
GL.GetProgramiv(Program, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength)
{
if (maxLength) {
GLchar *infoLog = new GLchar[maxLength];
GL.GetProgramInfoLog(Program, maxLength, &length, infoLog);
os::Printer::log(reinterpret_cast<const c8*>(infoLog), ELL_ERROR);
delete [] infoLog;
os::Printer::log(reinterpret_cast<const c8 *>(infoLog), ELL_ERROR);
delete[] infoLog;
}
return false;
@ -275,8 +255,7 @@ bool COpenGL3MaterialRenderer::linkProgram()
GL.GetProgramiv(Program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxlen);
if (maxlen == 0)
{
if (maxlen == 0) {
os::Printer::log("GLSL: failed to retrieve uniform information", ELL_ERROR);
return false;
}
@ -288,23 +267,21 @@ bool COpenGL3MaterialRenderer::linkProgram()
UniformInfo.clear();
UniformInfo.reallocate(num);
for (GLint i=0; i < num; ++i)
{
for (GLint i = 0; i < num; ++i) {
SUniformInfo ui;
memset(buf, 0, maxlen);
GLint size;
GL.GetActiveUniform(Program, i, maxlen, 0, &size, &ui.type, reinterpret_cast<GLchar*>(buf));
GL.GetActiveUniform(Program, i, maxlen, 0, &size, &ui.type, reinterpret_cast<GLchar *>(buf));
core::stringc name = "";
core::stringc name = "";
// array support, workaround for some bugged drivers.
for (s32 i = 0; i < maxlen; ++i)
{
for (s32 i = 0; i < maxlen; ++i) {
if (buf[i] == '[' || buf[i] == '\0')
break;
name += buf[i];
name += buf[i];
}
ui.name = name;
@ -313,29 +290,27 @@ bool COpenGL3MaterialRenderer::linkProgram()
UniformInfo.push_back(ui);
}
delete [] buf;
delete[] buf;
}
return true;
}
void COpenGL3MaterialRenderer::setBasicRenderStates(const SMaterial& material,
const SMaterial& lastMaterial,
bool resetAllRenderstates)
void COpenGL3MaterialRenderer::setBasicRenderStates(const SMaterial &material,
const SMaterial &lastMaterial,
bool resetAllRenderstates)
{
Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
}
s32 COpenGL3MaterialRenderer::getVertexShaderConstantID(const c8* name)
s32 COpenGL3MaterialRenderer::getVertexShaderConstantID(const c8 *name)
{
return getPixelShaderConstantID(name);
}
s32 COpenGL3MaterialRenderer::getPixelShaderConstantID(const c8* name)
s32 COpenGL3MaterialRenderer::getPixelShaderConstantID(const c8 *name)
{
for (u32 i = 0; i < UniformInfo.size(); ++i)
{
for (u32 i = 0; i < UniformInfo.size(); ++i) {
if (UniformInfo[i].name == name)
return i;
}
@ -343,115 +318,109 @@ s32 COpenGL3MaterialRenderer::getPixelShaderConstantID(const c8* name)
return -1;
}
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const f32* floats, int count)
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const f32 *floats, int count)
{
return setPixelShaderConstant(index, floats, count);
}
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const s32* ints, int count)
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const s32 *ints, int count)
{
return setPixelShaderConstant(index, ints, count);
}
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const u32* ints, int count)
bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const u32 *ints, int count)
{
return setPixelShaderConstant(index, ints, count);
}
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const f32* floats, int count)
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const f32 *floats, int count)
{
if(index < 0 || UniformInfo[index].location < 0)
if (index < 0 || UniformInfo[index].location < 0)
return false;
bool status = true;
switch (UniformInfo[index].type)
{
case GL_FLOAT:
GL.Uniform1fv(UniformInfo[index].location, count, floats);
break;
case GL_FLOAT_VEC2:
GL.Uniform2fv(UniformInfo[index].location, count/2, floats);
break;
case GL_FLOAT_VEC3:
GL.Uniform3fv(UniformInfo[index].location, count/3, floats);
break;
case GL_FLOAT_VEC4:
GL.Uniform4fv(UniformInfo[index].location, count/4, floats);
break;
case GL_FLOAT_MAT2:
GL.UniformMatrix2fv(UniformInfo[index].location, count/4, false, floats);
break;
case GL_FLOAT_MAT3:
GL.UniformMatrix3fv(UniformInfo[index].location, count/9, false, floats);
break;
case GL_FLOAT_MAT4:
GL.UniformMatrix4fv(UniformInfo[index].location, count/16, false, floats);
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
{
if(floats)
{
const GLint id = (GLint)(*floats);
GL.Uniform1iv(UniformInfo[index].location, 1, &id);
}
else
status = false;
}
break;
default:
switch (UniformInfo[index].type) {
case GL_FLOAT:
GL.Uniform1fv(UniformInfo[index].location, count, floats);
break;
case GL_FLOAT_VEC2:
GL.Uniform2fv(UniformInfo[index].location, count / 2, floats);
break;
case GL_FLOAT_VEC3:
GL.Uniform3fv(UniformInfo[index].location, count / 3, floats);
break;
case GL_FLOAT_VEC4:
GL.Uniform4fv(UniformInfo[index].location, count / 4, floats);
break;
case GL_FLOAT_MAT2:
GL.UniformMatrix2fv(UniformInfo[index].location, count / 4, false, floats);
break;
case GL_FLOAT_MAT3:
GL.UniformMatrix3fv(UniformInfo[index].location, count / 9, false, floats);
break;
case GL_FLOAT_MAT4:
GL.UniformMatrix4fv(UniformInfo[index].location, count / 16, false, floats);
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE: {
if (floats) {
const GLint id = (GLint)(*floats);
GL.Uniform1iv(UniformInfo[index].location, 1, &id);
} else
status = false;
break;
} break;
default:
status = false;
break;
}
return status;
}
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const s32* ints, int count)
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const s32 *ints, int count)
{
if(index < 0 || UniformInfo[index].location < 0)
if (index < 0 || UniformInfo[index].location < 0)
return false;
bool status = true;
switch (UniformInfo[index].type)
{
case GL_INT:
case GL_BOOL:
GL.Uniform1iv(UniformInfo[index].location, count, ints);
break;
case GL_INT_VEC2:
case GL_BOOL_VEC2:
GL.Uniform2iv(UniformInfo[index].location, count/2, ints);
break;
case GL_INT_VEC3:
case GL_BOOL_VEC3:
GL.Uniform3iv(UniformInfo[index].location, count/3, ints);
break;
case GL_INT_VEC4:
case GL_BOOL_VEC4:
GL.Uniform4iv(UniformInfo[index].location, count/4, ints);
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
GL.Uniform1iv(UniformInfo[index].location, 1, ints);
break;
default:
status = false;
break;
switch (UniformInfo[index].type) {
case GL_INT:
case GL_BOOL:
GL.Uniform1iv(UniformInfo[index].location, count, ints);
break;
case GL_INT_VEC2:
case GL_BOOL_VEC2:
GL.Uniform2iv(UniformInfo[index].location, count / 2, ints);
break;
case GL_INT_VEC3:
case GL_BOOL_VEC3:
GL.Uniform3iv(UniformInfo[index].location, count / 3, ints);
break;
case GL_INT_VEC4:
case GL_BOOL_VEC4:
GL.Uniform4iv(UniformInfo[index].location, count / 4, ints);
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
GL.Uniform1iv(UniformInfo[index].location, 1, ints);
break;
default:
status = false;
break;
}
return status;
}
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const u32* ints, int count)
bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const u32 *ints, int count)
{
os::Printer::log("Unsigned int support needs at least GLES 3.0", ELL_WARNING);
return false;
}
IVideoDriver* COpenGL3MaterialRenderer::getVideoDriver()
IVideoDriver *COpenGL3MaterialRenderer::getVideoDriver()
{
return Driver;
}