Forks/citra
1
0
Fork 0
mirror of https://github.com/PabloMK7/citra.git synced 2025-10-30 21:30:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

log: replace all NGLOG with LOG

Browse source
This commit is contained in:
wwylele 2018-06-29 14:18:07 +03:00
parent fde415968e
commit 7c5a76e58b
152 changed files with 1541 additions and 1541 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/video_core/command_processor.cpp
View file

@ -68,7 +68,7 @@ static void WriteUniformIntReg(Shader::ShaderSetup& setup, unsigned index,
const Math::Vec4<u8>& values) {
ASSERT(index < setup.uniforms.i.size());
setup.uniforms.i[index] = values;
NGLOG_TRACE(HW_GPU, "Set {} integer uniform {} to {:02x} {:02x} {:02x} {:02x}",
LOG_TRACE(HW_GPU, "Set {} integer uniform {} to {:02x} {:02x} {:02x} {:02x}",
GetShaderSetupTypeName(setup), index, values.x, values.y, values.z, values.w);
}
@ -90,7 +90,7 @@ static void WriteUniformFloatReg(ShaderRegs& config, Shader::ShaderSetup& setup,
auto& uniform = setup.uniforms.f[uniform_setup.index];
if (uniform_setup.index >= 96) {
NGLOG_ERROR(HW_GPU, "Invalid {} float uniform index {}", GetShaderSetupTypeName(setup),
LOG_ERROR(HW_GPU, "Invalid {} float uniform index {}", GetShaderSetupTypeName(setup),
(int)uniform_setup.index);
} else {
@ -108,7 +108,7 @@ static void WriteUniformFloatReg(ShaderRegs& config, Shader::ShaderSetup& setup,
uniform.x = float24::FromRaw(uniform_write_buffer[2] & 0xFFFFFF);
}
NGLOG_TRACE(HW_GPU, "Set {} float uniform {:x} to ({} {} {} {})",
LOG_TRACE(HW_GPU, "Set {} float uniform {:x} to ({} {} {} {})",
GetShaderSetupTypeName(setup), (int)uniform_setup.index,
uniform.x.ToFloat32(), uniform.y.ToFloat32(), uniform.z.ToFloat32(),
uniform.w.ToFloat32());
@ -123,7 +123,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
auto& regs = g_state.regs;
if (id >= Regs::NUM_REGS) {
NGLOG_ERROR(
LOG_ERROR(
HW_GPU,
"Commandlist tried to write to invalid register 0x{:03X} (value: {:08X}, mask: {:X})",
id, value, mask);
@ -184,7 +184,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
auto& setup = regs.pipeline.vs_default_attributes_setup;
if (setup.index >= 16) {
NGLOG_ERROR(HW_GPU, "Invalid VS default attribute index {}", (int)setup.index);
LOG_ERROR(HW_GPU, "Invalid VS default attribute index {}", (int)setup.index);
break;
}
@ -198,7 +198,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
((default_attr_write_buffer[2] >> 24) & 0xFF));
attribute.x = float24::FromRaw(default_attr_write_buffer[2] & 0xFFFFFF);
NGLOG_TRACE(HW_GPU, "Set default VS attribute {:x} to ({} {} {} {})", (int)setup.index,
LOG_TRACE(HW_GPU, "Set default VS attribute {:x} to ({} {} {} {})", (int)setup.index,
attribute.x.ToFloat32(), attribute.y.ToFloat32(), attribute.z.ToFloat32(),
attribute.w.ToFloat32());
@ -474,7 +474,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
case PICA_REG_INDEX_WORKAROUND(gs.program.set_word[7], 0x2a3): {
u32& offset = g_state.regs.gs.program.offset;
if (offset >= 4096) {
NGLOG_ERROR(HW_GPU, "Invalid GS program offset {}", offset);
LOG_ERROR(HW_GPU, "Invalid GS program offset {}", offset);
} else {
g_state.gs.program_code[offset] = value;
g_state.gs.MarkProgramCodeDirty();
@ -493,7 +493,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
case PICA_REG_INDEX_WORKAROUND(gs.swizzle_patterns.set_word[7], 0x2ad): {
u32& offset = g_state.regs.gs.swizzle_patterns.offset;
if (offset >= g_state.gs.swizzle_data.size()) {
NGLOG_ERROR(HW_GPU, "Invalid GS swizzle pattern offset {}", offset);
LOG_ERROR(HW_GPU, "Invalid GS swizzle pattern offset {}", offset);
} else {
g_state.gs.swizzle_data[offset] = value;
g_state.gs.MarkSwizzleDataDirty();
@ -543,7 +543,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
case PICA_REG_INDEX_WORKAROUND(vs.program.set_word[7], 0x2d3): {
u32& offset = g_state.regs.vs.program.offset;
if (offset >= 512) {
NGLOG_ERROR(HW_GPU, "Invalid VS program offset {}", offset);
LOG_ERROR(HW_GPU, "Invalid VS program offset {}", offset);
} else {
g_state.vs.program_code[offset] = value;
g_state.vs.MarkProgramCodeDirty();
@ -566,7 +566,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
case PICA_REG_INDEX_WORKAROUND(vs.swizzle_patterns.set_word[7], 0x2dd): {
u32& offset = g_state.regs.vs.swizzle_patterns.offset;
if (offset >= g_state.vs.swizzle_data.size()) {
NGLOG_ERROR(HW_GPU, "Invalid VS swizzle pattern offset {}", offset);
LOG_ERROR(HW_GPU, "Invalid VS swizzle pattern offset {}", offset);
} else {
g_state.vs.swizzle_data[offset] = value;
g_state.vs.MarkSwizzleDataDirty();

8
src/video_core/debug_utils/debug_utils.cpp
View file

@ -178,7 +178,7 @@ void DumpShader(const std::string& filename, const ShaderRegs& config,
}
} catch (const std::out_of_range&) {
DEBUG_ASSERT_MSG(false, "Unknown output attribute mapping");
NGLOG_ERROR(HW_GPU,
LOG_ERROR(HW_GPU,
"Unknown output attribute mapping: {:03x}, {:03x}, {:03x}, {:03x}",
(int)output_attributes[i].map_x.Value(),
(int)output_attributes[i].map_y.Value(),
@ -278,7 +278,7 @@ bool g_is_pica_tracing = false;
void StartPicaTracing() {
if (g_is_pica_tracing) {
NGLOG_WARNING(HW_GPU, "StartPicaTracing called even though tracing already running!");
LOG_WARNING(HW_GPU, "StartPicaTracing called even though tracing already running!");
return;
}
@ -299,7 +299,7 @@ void OnPicaRegWrite(PicaTrace::Write write) {
std::unique_ptr<PicaTrace> FinishPicaTracing() {
if (!g_is_pica_tracing) {
NGLOG_WARNING(HW_GPU, "FinishPicaTracing called even though tracing isn't running!");
LOG_WARNING(HW_GPU, "FinishPicaTracing called even though tracing isn't running!");
return {};
}
@ -457,7 +457,7 @@ void DumpTevStageConfig(const std::array<TexturingRegs::TevStageConfig, 6>& stag
GetTevStageConfigColorCombinerString(tev_stage) + " " +
GetTevStageConfigAlphaCombinerString(tev_stage) + "\n";
}
NGLOG_TRACE(HW_GPU, "{}", stage_info);
LOG_TRACE(HW_GPU, "{}", stage_info);
}
} // namespace DebugUtils

2
src/video_core/gpu_debugger.h
View file

@ -30,7 +30,7 @@ public:
virtual void GXCommandProcessed(int total_command_count) {
const Service::GSP::Command& cmd =
observed->ReadGXCommandHistory(total_command_count - 1);
NGLOG_TRACE(Debug_GPU, "Received command: id={:x}", (int)cmd.id.Value());
LOG_TRACE(Debug_GPU, "Received command: id={:x}", (int)cmd.id.Value());
}
protected:

2
src/video_core/primitive_assembly.cpp
View file

@ -48,7 +48,7 @@ void PrimitiveAssembler<VertexType>::SubmitVertex(const VertexType& vtx,
break;
default:
NGLOG_ERROR(HW_GPU, "Unknown triangle topology {:x}:", (int)topology);
LOG_ERROR(HW_GPU, "Unknown triangle topology {:x}:", (int)topology);
break;
}
}

2
src/video_core/regs_framebuffer.h
View file

@ -200,7 +200,7 @@ struct FramebufferRegs {
case ColorFormat::RGBA4:
return 2;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown color format {}", static_cast<u32>(format));
LOG_CRITICAL(HW_GPU, "Unknown color format {}", static_cast<u32>(format));
UNIMPLEMENTED();
}
}

8
src/video_core/renderer_opengl/gl_rasterizer.cpp
View file

@ -43,7 +43,7 @@ RasterizerOpenGL::RasterizerOpenGL()
allow_shadow = GLAD_GL_ARB_shader_image_load_store && GLAD_GL_ARB_shader_image_size &&
GLAD_GL_ARB_framebuffer_no_attachments;
if (!allow_shadow) {
NGLOG_WARNING(
LOG_WARNING(
Render_OpenGL,
"Shadow might not be able to render because of unsupported OpenGL extensions.");
}
@ -432,7 +432,7 @@ bool RasterizerOpenGL::AccelerateDrawBatchInternal(bool is_indexed, bool use_gs)
auto [vs_input_index_min, vs_input_index_max, vs_input_size] = AnalyzeVertexArray(is_indexed);
if (vs_input_size > VERTEX_BUFFER_SIZE) {
NGLOG_WARNING(Render_OpenGL, "Too large vertex input size {}", vs_input_size);
LOG_WARNING(Render_OpenGL, "Too large vertex input size {}", vs_input_size);
return false;
}
@ -453,7 +453,7 @@ bool RasterizerOpenGL::AccelerateDrawBatchInternal(bool is_indexed, bool use_gs)
std::size_t index_buffer_size = regs.pipeline.num_vertices * (index_u16 ? 2 : 1);
if (index_buffer_size > INDEX_BUFFER_SIZE) {
NGLOG_WARNING(Render_OpenGL, "Too large index input size {}", index_buffer_size);
LOG_WARNING(Render_OpenGL, "Too large index input size {}", index_buffer_size);
return false;
}
@ -1600,7 +1600,7 @@ void RasterizerOpenGL::SyncCullMode() {
break;
default:
NGLOG_CRITICAL(Render_OpenGL, "Unknown cull mode {}",
LOG_CRITICAL(Render_OpenGL, "Unknown cull mode {}",
static_cast<u32>(regs.rasterizer.cull_mode.Value()));
UNIMPLEMENTED();
break;

2
src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
View file

@ -1390,7 +1390,7 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(
// Make sure that framebuffers don't overlap if both color and depth are being used
if (using_color_fb && using_depth_fb &&
boost::icl::length(color_vp_interval & depth_vp_interval)) {
NGLOG_CRITICAL(Render_OpenGL, "Color and depth framebuffer memory regions overlap; "
LOG_CRITICAL(Render_OpenGL, "Color and depth framebuffer memory regions overlap; "
"overlapping framebuffers not supported!");
using_depth_fb = false;
}

12
src/video_core/renderer_opengl/gl_shader_decompiler.cpp
View file

@ -546,9 +546,9 @@ private:
const CompareOp op_y = instr.common.compare_op.y.Value();
if (cmp_ops.find(op_x) == cmp_ops.end()) {
NGLOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op_x));
LOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op_x));
} else if (cmp_ops.find(op_y) == cmp_ops.end()) {
NGLOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op_y));
LOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op_y));
} else if (op_x != op_y) {
shader.AddLine("conditional_code.x = " + src1 + ".x " +
cmp_ops.find(op_x)->second.first + " " + src2 + ".x;");
@ -572,7 +572,7 @@ private:
}
default: {
NGLOG_ERROR(HW_GPU, "Unhandled arithmetic instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled arithmetic instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
throw DecompileFail("Unhandled instruction");
@ -616,7 +616,7 @@ private:
SetDest(swizzle, dest_reg, src1 + " * " + src2 + " + " + src3, 4, 4);
}
} else {
NGLOG_ERROR(HW_GPU, "Unhandled multiply-add instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled multiply-add instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
throw DecompileFail("Unhandled instruction");
@ -770,7 +770,7 @@ private:
}
default: {
NGLOG_ERROR(HW_GPU, "Unhandled instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
throw DecompileFail("Unhandled instruction");
@ -921,7 +921,7 @@ boost::optional<std::string> DecompileProgram(const ProgramCode& program_code,
inputreg_getter, outputreg_getter, sanitize_mul, is_gs);
return generator.MoveShaderCode();
} catch (const DecompileFail& exception) {
NGLOG_INFO(HW_GPU, "Shader decompilation failed: {}", exception.what());
LOG_INFO(HW_GPU, "Shader decompilation failed: {}", exception.what());
return boost::none;
}
}

30
src/video_core/renderer_opengl/gl_shader_gen.cpp
View file

@ -269,7 +269,7 @@ void PicaGSConfigCommonRaw::Init(const Pica::Regs& regs) {
if (static_cast<size_t>(semantic) < 24) {
semantic_maps[static_cast<size_t>(semantic)] = {attrib, comp};
} else if (semantic != VSOutputAttributes::INVALID) {
NGLOG_ERROR(Render_OpenGL, "Invalid/unknown semantic id: {}",
LOG_ERROR(Render_OpenGL, "Invalid/unknown semantic id: {}",
static_cast<u32>(semantic));
}
}
@ -320,7 +320,7 @@ static std::string SampleTexture(const PicaFSConfig& config, unsigned texture_un
case TexturingRegs::TextureConfig::ShadowCube:
return "shadowTextureCube(texcoord0, texcoord0_w)";
default:
NGLOG_CRITICAL(HW_GPU, "Unhandled texture type {:x}",
LOG_CRITICAL(HW_GPU, "Unhandled texture type {:x}",
static_cast<int>(state.texture0_type));
UNIMPLEMENTED();
return "texture(tex0, texcoord0)";
@ -336,7 +336,7 @@ static std::string SampleTexture(const PicaFSConfig& config, unsigned texture_un
if (state.proctex.enable) {
return "ProcTex()";
} else {
NGLOG_DEBUG(Render_OpenGL, "Using Texture3 without enabling it");
LOG_DEBUG(Render_OpenGL, "Using Texture3 without enabling it");
return "vec4(0.0)";
}
default:
@ -383,7 +383,7 @@ static void AppendSource(std::string& out, const PicaFSConfig& config,
break;
default:
out += "vec4(0.0)";
NGLOG_CRITICAL(Render_OpenGL, "Unknown source op {}", static_cast<u32>(source));
LOG_CRITICAL(Render_OpenGL, "Unknown source op {}", static_cast<u32>(source));
break;
}
}
@ -441,7 +441,7 @@ static void AppendColorModifier(std::string& out, const PicaFSConfig& config,
break;
default:
out += "vec3(0.0)";
NGLOG_CRITICAL(Render_OpenGL, "Unknown color modifier op {}", static_cast<u32>(modifier));
LOG_CRITICAL(Render_OpenGL, "Unknown color modifier op {}", static_cast<u32>(modifier));
break;
}
}
@ -490,7 +490,7 @@ static void AppendAlphaModifier(std::string& out, const PicaFSConfig& config,
break;
default:
out += "0.0";
NGLOG_CRITICAL(Render_OpenGL, "Unknown alpha modifier op {}", static_cast<u32>(modifier));
LOG_CRITICAL(Render_OpenGL, "Unknown alpha modifier op {}", static_cast<u32>(modifier));
break;
}
}
@ -534,7 +534,7 @@ static void AppendColorCombiner(std::string& out, TevStageConfig::Operation oper
break;
default:
out += "vec3(0.0)";
NGLOG_CRITICAL(Render_OpenGL, "Unknown color combiner operation: {}",
LOG_CRITICAL(Render_OpenGL, "Unknown color combiner operation: {}",
static_cast<u32>(operation));
break;
}
@ -575,7 +575,7 @@ static void AppendAlphaCombiner(std::string& out, TevStageConfig::Operation oper
break;
default:
out += "0.0";
NGLOG_CRITICAL(Render_OpenGL, "Unknown alpha combiner operation: {}",
LOG_CRITICAL(Render_OpenGL, "Unknown alpha combiner operation: {}",
static_cast<u32>(operation));
break;
}
@ -606,7 +606,7 @@ static void AppendAlphaTestCondition(std::string& out, FramebufferRegs::CompareF
default:
out += "false";
NGLOG_CRITICAL(Render_OpenGL, "Unknown alpha test condition {}", static_cast<u32>(func));
LOG_CRITICAL(Render_OpenGL, "Unknown alpha test condition {}", static_cast<u32>(func));
break;
}
}
@ -776,7 +776,7 @@ static void WriteLighting(std::string& out, const PicaFSConfig& config) {
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown lighting LUT input {}\n", (int)input);
LOG_CRITICAL(HW_GPU, "Unknown lighting LUT input {}\n", (int)input);
UNIMPLEMENTED();
index = "0.0";
break;
@ -992,7 +992,7 @@ void AppendProcTexShiftOffset(std::string& out, const std::string& v, ProcTexShi
out += offset + " * (((int(" + v + ") + 1) / 2) % 2)";
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown shift mode {}", static_cast<u32>(mode));
LOG_CRITICAL(HW_GPU, "Unknown shift mode {}", static_cast<u32>(mode));
out += "0";
break;
}
@ -1018,7 +1018,7 @@ void AppendProcTexClamp(std::string& out, const std::string& var, ProcTexClamp m
out += var + " = " + var + " > 0.5 ? 1.0 : 0.0;\n";
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown clamp mode {}", static_cast<u32>(mode));
LOG_CRITICAL(HW_GPU, "Unknown clamp mode {}", static_cast<u32>(mode));
out += var + " = " + "min(" + var + ", 1.0);\n";
break;
}
@ -1059,7 +1059,7 @@ void AppendProcTexCombineAndMap(std::string& out, ProcTexCombiner combiner,
combined = "min(((u + v) * 0.5 + sqrt(u * u + v * v)) * 0.5, 1.0)";
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown combiner {}", static_cast<u32>(combiner));
LOG_CRITICAL(HW_GPU, "Unknown combiner {}", static_cast<u32>(combiner));
combined = "0.0";
break;
}
@ -1126,7 +1126,7 @@ float ProcTexNoiseCoef(vec2 x) {
if (config.state.proctex.coord < 3) {
out += "vec2 uv = abs(texcoord" + std::to_string(config.state.proctex.coord) + ");\n";
} else {
NGLOG_CRITICAL(Render_OpenGL, "Unexpected proctex.coord >= 3");
LOG_CRITICAL(Render_OpenGL, "Unexpected proctex.coord >= 3");
out += "vec2 uv = abs(texcoord0);\n";
}
@ -1499,7 +1499,7 @@ vec4 secondary_fragment_color = vec4(0.0);
} else if (state.fog_mode == TexturingRegs::FogMode::Gas) {
Core::Telemetry().AddField(Telemetry::FieldType::Session, "VideoCore_Pica_UseGasMode",
true);
NGLOG_CRITICAL(Render_OpenGL, "Unimplemented gas mode");
LOG_CRITICAL(Render_OpenGL, "Unimplemented gas mode");
out += "discard; }";
return out;
}

14
src/video_core/renderer_opengl/gl_shader_util.cpp
View file

@ -28,7 +28,7 @@ GLuint LoadShader(const char* source, GLenum type) {
GLuint shader_id = glCreateShader(type);
glShaderSource(shader_id, 1, &source, nullptr);
NGLOG_DEBUG(Render_OpenGL, "Compiling {} shader...", debug_type);
LOG_DEBUG(Render_OpenGL, "Compiling {} shader...", debug_type);
glCompileShader(shader_id);
GLint result = GL_FALSE;
@ -40,11 +40,11 @@ GLuint LoadShader(const char* source, GLenum type) {
std::vector<char> shader_error(info_log_length);
glGetShaderInfoLog(shader_id, info_log_length, nullptr, &shader_error[0]);
if (result == GL_TRUE) {
NGLOG_DEBUG(Render_OpenGL, "{}", &shader_error[0]);
LOG_DEBUG(Render_OpenGL, "{}", &shader_error[0]);
} else {
NGLOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type,
LOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type,
&shader_error[0]);
NGLOG_ERROR(Render_OpenGL, "Shader source code:\n{}", source);
LOG_ERROR(Render_OpenGL, "Shader source code:\n{}", source);
}
}
return shader_id;
@ -52,7 +52,7 @@ GLuint LoadShader(const char* source, GLenum type) {
GLuint LoadProgram(bool separable_program, const std::vector<GLuint>& shaders) {
// Link the program
NGLOG_DEBUG(Render_OpenGL, "Linking program...");
LOG_DEBUG(Render_OpenGL, "Linking program...");
GLuint program_id = glCreateProgram();
@ -78,9 +78,9 @@ GLuint LoadProgram(bool separable_program, const std::vector<GLuint>& shaders) {
std::vector<char> program_error(info_log_length);
glGetProgramInfoLog(program_id, info_log_length, nullptr, &program_error[0]);
if (result == GL_TRUE) {
NGLOG_DEBUG(Render_OpenGL, "{}", &program_error[0]);
LOG_DEBUG(Render_OpenGL, "{}", &program_error[0]);
} else {
NGLOG_ERROR(Render_OpenGL, "Error linking shader:\n{}", &program_error[0]);
LOG_ERROR(Render_OpenGL, "Error linking shader:\n{}", &program_error[0]);
}
}

20
src/video_core/renderer_opengl/pica_to_gl.h
View file

@ -39,7 +39,7 @@ inline GLenum TextureFilterMode(Pica::TexturingRegs::TextureConfig::TextureFilte
// Range check table for input
if (index >= filter_mode_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown texture filtering mode {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown texture filtering mode {}", index);
UNREACHABLE();
return GL_LINEAR;
@ -49,7 +49,7 @@ inline GLenum TextureFilterMode(Pica::TexturingRegs::TextureConfig::TextureFilte
// Check for dummy values indicating an unknown mode
if (gl_mode == 0) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown texture filtering mode {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown texture filtering mode {}", index);
UNIMPLEMENTED();
return GL_LINEAR;
@ -76,7 +76,7 @@ inline GLenum WrapMode(Pica::TexturingRegs::TextureConfig::WrapMode mode) {
// Range check table for input
if (index >= wrap_mode_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown texture wrap mode {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown texture wrap mode {}", index);
UNREACHABLE();
return GL_CLAMP_TO_EDGE;
@ -86,14 +86,14 @@ inline GLenum WrapMode(Pica::TexturingRegs::TextureConfig::WrapMode mode) {
Core::Telemetry().AddField(Telemetry::FieldType::Session,
"VideoCore_Pica_UnsupportedTextureWrapMode",
static_cast<u32>(index));
NGLOG_WARNING(Render_OpenGL, "Using texture wrap mode {}", index);
LOG_WARNING(Render_OpenGL, "Using texture wrap mode {}", index);
}
GLenum gl_mode = wrap_mode_table[index];
// Check for dummy values indicating an unknown mode
if (gl_mode == 0) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown texture wrap mode {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown texture wrap mode {}", index);
UNIMPLEMENTED();
return GL_CLAMP_TO_EDGE;
@ -115,7 +115,7 @@ inline GLenum BlendEquation(Pica::FramebufferRegs::BlendEquation equation) {
// Range check table for input
if (index >= blend_equation_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown blend equation {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown blend equation {}", index);
// This return value is hwtested, not just a stub
return GL_FUNC_ADD;
@ -147,7 +147,7 @@ inline GLenum BlendFunc(Pica::FramebufferRegs::BlendFactor factor) {
// Range check table for input
if (index >= blend_func_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown blend factor {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown blend factor {}", index);
UNREACHABLE();
return GL_ONE;
@ -180,7 +180,7 @@ inline GLenum LogicOp(Pica::FramebufferRegs::LogicOp op) {
// Range check table for input
if (index >= logic_op_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown logic op {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown logic op {}", index);
UNREACHABLE();
return GL_COPY;
@ -205,7 +205,7 @@ inline GLenum CompareFunc(Pica::FramebufferRegs::CompareFunc func) {
// Range check table for input
if (index >= compare_func_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown compare function {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown compare function {}", index);
UNREACHABLE();
return GL_ALWAYS;
@ -230,7 +230,7 @@ inline GLenum StencilOp(Pica::FramebufferRegs::StencilAction action) {
// Range check table for input
if (index >= stencil_op_table.size()) {
NGLOG_CRITICAL(Render_OpenGL, "Unknown stencil op {}", index);
LOG_CRITICAL(Render_OpenGL, "Unknown stencil op {}", index);
UNREACHABLE();
return GL_KEEP;

10
src/video_core/renderer_opengl/renderer_opengl.cpp
View file

@ -171,7 +171,7 @@ void RendererOpenGL::LoadFBToScreenInfo(const GPU::Regs::FramebufferConfig& fram
? (!right_eye ? framebuffer.address_left1 : framebuffer.address_right1)
: (!right_eye ? framebuffer.address_left2 : framebuffer.address_right2);
NGLOG_TRACE(Render_OpenGL, "0x{:08x} bytes from 0x{:08x}({}x{}), fmt {:x}",
LOG_TRACE(Render_OpenGL, "0x{:08x} bytes from 0x{:08x}({}x{}), fmt {:x}",
framebuffer.stride * framebuffer.height, framebuffer_addr, (int)framebuffer.width,
(int)framebuffer.height, (int)framebuffer.format);
@ -494,7 +494,7 @@ static void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum
level = Log::Level::Debug;
break;
}
NGLOG_GENERIC(Log::Class::Render_OpenGL, level, "{} {} {}: {}", GetSource(source),
LOG_GENERIC(Log::Class::Render_OpenGL, level, "{} {} {}: {}", GetSource(source),
GetType(type), id, message);
}
@ -511,9 +511,9 @@ bool RendererOpenGL::Init() {
const char* gpu_vendor{reinterpret_cast<char const*>(glGetString(GL_VENDOR))};
const char* gpu_model{reinterpret_cast<char const*>(glGetString(GL_RENDERER))};
NGLOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
NGLOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
NGLOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
LOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
LOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Vendor", gpu_vendor);
Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);

2
src/video_core/shader/shader.cpp
View file

@ -65,7 +65,7 @@ OutputVertex OutputVertex::FromAttributeBuffer(const RasterizerRegs& regs,
ret.color[i] = float24::FromFloat32(c < 1.0f ? c : 1.0f);
}
NGLOG_TRACE(HW_GPU,
LOG_TRACE(HW_GPU,
"Output vertex: pos({:.2}, {:.2}, {:.2}, {:.2}), quat({:.2}, {:.2}, {:.2}, {:.2}), "
"col({:.2}, {:.2}, {:.2}, {:.2}), tc0({:.2}, {:.2}), view({:.2}, {:.2}, {:.2})",
ret.pos.x.ToFloat32(), ret.pos.y.ToFloat32(), ret.pos.z.ToFloat32(),

8
src/video_core/shader/shader_interpreter.cpp
View file

@ -404,7 +404,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
break;
default:
NGLOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op));
LOG_ERROR(HW_GPU, "Unknown compare mode {:x}", static_cast<int>(op));
break;
}
}
@ -446,7 +446,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
}
default:
NGLOG_ERROR(HW_GPU, "Unhandled arithmetic instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled arithmetic instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
DEBUG_ASSERT(false);
@ -535,7 +535,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
}
Record<DebugDataRecord::DEST_OUT>(debug_data, iteration, dest);
} else {
NGLOG_ERROR(HW_GPU, "Unhandled multiply-add instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled multiply-add instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
}
@ -653,7 +653,7 @@ static void RunInterpreter(const ShaderSetup& setup, UnitState& state, DebugData
}
default:
NGLOG_ERROR(HW_GPU, "Unhandled instruction: 0x{:02x} ({}): 0x{:08x}",
LOG_ERROR(HW_GPU, "Unhandled instruction: 0x{:02x} ({}): 0x{:08x}",
(int)instr.opcode.Value().EffectiveOpCode(),
instr.opcode.Value().GetInfo().name, instr.hex);
break;

6
src/video_core/shader/shader_jit_x64_compiler.cpp
View file

@ -161,7 +161,7 @@ static const u8 NO_SRC_REG_SWIZZLE = 0x1b;
static const u8 NO_DEST_REG_MASK = 0xf;
static void LogCritical(const char* msg) {
NGLOG_CRITICAL(HW_GPU, "{}", msg);
LOG_CRITICAL(HW_GPU, "{}", msg);
}
void JitShader::Compile_Assert(bool condition, const char* msg) {
@ -858,7 +858,7 @@ void JitShader::Compile_NextInstr() {
((*this).*instr_func)(instr);
} else {
// Unhandled instruction
NGLOG_CRITICAL(HW_GPU, "Unhandled instruction: 0x{:02x} (0x{:08x})",
LOG_CRITICAL(HW_GPU, "Unhandled instruction: 0x{:02x} (0x{:08x})",
static_cast<u32>(instr.opcode.Value().EffectiveOpCode()), instr.hex);
}
}
@ -945,7 +945,7 @@ void JitShader::Compile(const std::array<u32, MAX_PROGRAM_CODE_LENGTH>* program_
ready();
ASSERT_MSG(getSize() <= MAX_SHADER_SIZE, "Compiled a shader that exceeds the allocated size!");
NGLOG_DEBUG(HW_GPU, "Compiled shader size={}", getSize());
LOG_DEBUG(HW_GPU, "Compiled shader size={}", getSize());
}
JitShader::JitShader() : Xbyak::CodeGenerator(MAX_SHADER_SIZE) {

2
src/video_core/swrasterizer/clipper.cpp
View file

@ -173,7 +173,7 @@ void ProcessTriangle(const OutputVertex& v0, const OutputVertex& v1, const Outpu
InitScreenCoordinates(vtx2);
NGLOG_TRACE(
LOG_TRACE(
Render_Software,
"Triangle {}/{} at position ({:.3}, {:.3}, {:.3}, {:.3f}), "
"({:.3}, {:.3}, {:.3}, {:.3}), ({:.3}, {:.3}, {:.3}, {:.3}) and "

16
src/video_core/swrasterizer/framebuffer.cpp
View file

@ -57,7 +57,7 @@ void DrawPixel(int x, int y, const Math::Vec4<u8>& color) {
break;
default:
NGLOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
LOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
static_cast<u32>(framebuffer.color_format.Value()));
UNIMPLEMENTED();
}
@ -93,7 +93,7 @@ const Math::Vec4<u8> GetPixel(int x, int y) {
return Color::DecodeRGBA4(src_pixel);
default:
NGLOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
LOG_CRITICAL(Render_Software, "Unknown framebuffer color format {:x}",
static_cast<u32>(framebuffer.color_format.Value()));
UNIMPLEMENTED();
}
@ -123,7 +123,7 @@ u32 GetDepth(int x, int y) {
case FramebufferRegs::DepthFormat::D24S8:
return Color::DecodeD24S8(src_pixel).x;
default:
NGLOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
LOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
static_cast<u32>(framebuffer.depth_format.Value()));
UNIMPLEMENTED();
return 0;
@ -149,7 +149,7 @@ u8 GetStencil(int x, int y) {
return Color::DecodeD24S8(src_pixel).y;
default:
NGLOG_WARNING(
LOG_WARNING(
HW_GPU,
"GetStencil called for function which doesn't have a stencil component (format {})",
static_cast<u32>(framebuffer.depth_format.Value()));
@ -185,7 +185,7 @@ void SetDepth(int x, int y, u32 value) {
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
LOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
static_cast<u32>(framebuffer.depth_format.Value()));
UNIMPLEMENTED();
break;
@ -217,7 +217,7 @@ void SetStencil(int x, int y, u8 value) {
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
LOG_CRITICAL(HW_GPU, "Unimplemented depth format {}",
static_cast<u32>(framebuffer.depth_format.Value()));
UNIMPLEMENTED();
break;
@ -253,7 +253,7 @@ u8 PerformStencilAction(FramebufferRegs::StencilAction action, u8 old_stencil, u
return old_stencil - 1;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown stencil action {:x}", (int)action);
LOG_CRITICAL(HW_GPU, "Unknown stencil action {:x}", (int)action);
UNIMPLEMENTED();
return 0;
}
@ -297,7 +297,7 @@ Math::Vec4<u8> EvaluateBlendEquation(const Math::Vec4<u8>& src, const Math::Vec4
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown RGB blend equation 0x{:x}", static_cast<u8>(equation));
LOG_CRITICAL(HW_GPU, "Unknown RGB blend equation 0x{:x}", static_cast<u8>(equation));
UNIMPLEMENTED();
}

4
src/video_core/swrasterizer/lighting.cpp
View file

@ -53,7 +53,7 @@ std::tuple<Math::Vec4<u8>, Math::Vec4<u8>> ComputeFragmentsColors(
surface_normal = Math::MakeVec(0.0f, 0.0f, 1.0f);
surface_tangent = perturbation;
} else {
NGLOG_ERROR(HW_GPU, "Unknown bump mode {}",
LOG_ERROR(HW_GPU, "Unknown bump mode {}",
static_cast<u32>(lighting.config0.bump_mode.Value()));
}
} else {
@ -143,7 +143,7 @@ std::tuple<Math::Vec4<u8>, Math::Vec4<u8>> ComputeFragmentsColors(
}
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown lighting LUT input {}\n", static_cast<u32>(input));
LOG_CRITICAL(HW_GPU, "Unknown lighting LUT input {}\n", static_cast<u32>(input));
UNIMPLEMENTED();
result = 0.0f;
}

6
src/video_core/swrasterizer/proctex.cpp
View file

@ -77,7 +77,7 @@ static float GetShiftOffset(float v, ProcTexShift mode, ProcTexClamp clamp_mode)
case ProcTexShift::Even:
return offset * ((((int)v + 1) / 2) % 2);
default:
NGLOG_CRITICAL(HW_GPU, "Unknown shift mode {}", static_cast<u32>(mode));
LOG_CRITICAL(HW_GPU, "Unknown shift mode {}", static_cast<u32>(mode));
return 0;
}
};
@ -107,7 +107,7 @@ static void ClampCoord(float& coord, ProcTexClamp mode) {
coord = 1.0f;
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown clamp mode {}", static_cast<u32>(mode));
LOG_CRITICAL(HW_GPU, "Unknown clamp mode {}", static_cast<u32>(mode));
coord = std::min(coord, 1.0f);
break;
}
@ -148,7 +148,7 @@ float CombineAndMap(float u, float v, ProcTexCombiner combiner,
f = std::min(((u + v) * 0.5f + std::sqrt(u * u + v * v)) * 0.5f, 1.0f);
break;
default:
NGLOG_CRITICAL(HW_GPU, "Unknown combiner {}", static_cast<u32>(combiner));
LOG_CRITICAL(HW_GPU, "Unknown combiner {}", static_cast<u32>(combiner));
f = 0.0f;
break;
}

6
src/video_core/swrasterizer/rasterizer.cpp
View file

@ -363,7 +363,7 @@ static void ProcessTriangleInternal(const Vertex& v0, const Vertex& v1, const Ve
}
default:
// TODO: Change to LOG_ERROR when more types are handled.
NGLOG_DEBUG(HW_GPU, "Unhandled texture type {:x}",
LOG_DEBUG(HW_GPU, "Unhandled texture type {:x}",
(int)texture.config.type);
UNIMPLEMENTED();
break;
@ -513,7 +513,7 @@ static void ProcessTriangleInternal(const Vertex& v0, const Vertex& v1, const Ve
return combiner_output;
default:
NGLOG_ERROR(HW_GPU, "Unknown color combiner source {}", (int)source);
LOG_ERROR(HW_GPU, "Unknown color combiner source {}", (int)source);
UNIMPLEMENTED();
return {0, 0, 0, 0};
}
@ -844,7 +844,7 @@ static void ProcessTriangleInternal(const Vertex& v0, const Vertex& v1, const Ve
return std::min(combiner_output.a(), static_cast<u8>(255 - dest.a()));
default:
NGLOG_CRITICAL(HW_GPU, "Unknown blend factor {:x}",
LOG_CRITICAL(HW_GPU, "Unknown blend factor {:x}",
static_cast<u32>(factor));
UNIMPLEMENTED();
break;

6
src/video_core/swrasterizer/texturing.cpp
View file

@ -48,7 +48,7 @@ int GetWrappedTexCoord(TexturingRegs::TextureConfig::WrapMode mode, int val, uns
}
default:
NGLOG_ERROR(HW_GPU, "Unknown texture coordinate wrapping mode {:x}", (int)mode);
LOG_ERROR(HW_GPU, "Unknown texture coordinate wrapping mode {:x}", (int)mode);
UNIMPLEMENTED();
return 0;
}
@ -197,7 +197,7 @@ Math::Vec3<u8> ColorCombine(TevStageConfig::Operation op, const Math::Vec3<u8> i
return {(u8)result, (u8)result, (u8)result};
}
default:
NGLOG_ERROR(HW_GPU, "Unknown color combiner operation {}", (int)op);
LOG_ERROR(HW_GPU, "Unknown color combiner operation {}", (int)op);
UNIMPLEMENTED();
return {0, 0, 0};
}
@ -234,7 +234,7 @@ u8 AlphaCombine(TevStageConfig::Operation op, const std::array<u8, 3>& input) {
return (std::min(255, (input[0] + input[1])) * input[2]) / 255;
default:
NGLOG_ERROR(HW_GPU, "Unknown alpha combiner operation {}", (int)op);
LOG_ERROR(HW_GPU, "Unknown alpha combiner operation {}", (int)op);
UNIMPLEMENTED();
return 0;
}

2
src/video_core/texture/texture_decode.cpp
View file

@ -206,7 +206,7 @@ Math::Vec4<u8> LookupTexelInTile(const u8* source, unsigned int x, unsigned int
}
default:
NGLOG_ERROR(HW_GPU, "Unknown texture format: {:x}", (u32)info.format);
LOG_ERROR(HW_GPU, "Unknown texture format: {:x}", (u32)info.format);
DEBUG_ASSERT(false);
return {};
}

6
src/video_core/vertex_loader.cpp
View file

@ -37,7 +37,7 @@ void VertexLoader::Setup(const PipelineRegs& regs) {
// TODO: What happens if a loader overwrites a previous one's data?
for (unsigned component = 0; component < loader_config.component_count; ++component) {
if (component >= 12) {
NGLOG_ERROR(
LOG_ERROR(
HW_GPU,
"Overflow in the vertex attribute loader {} trying to load component {}",
loader, component);
@ -137,7 +137,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
comp == 3 ? float24::FromFloat32(1.0f) : float24::FromFloat32(0.0f);
}
NGLOG_TRACE(HW_GPU,
LOG_TRACE(HW_GPU,
"Loaded {} components of attribute {:x} for vertex {:x} (index {:x}) from "
"0x{:08x} + 0x{:08x} + 0x{:04x}: {} {} {} {}",
vertex_attribute_elements[i], i, vertex, index, base_address,
@ -147,7 +147,7 @@ void VertexLoader::LoadVertex(u32 base_address, int index, int vertex,
} else if (vertex_attribute_is_default[i]) {
// Load the default attribute if we're configured to do so
input.attr[i] = g_state.input_default_attributes.attr[i];
NGLOG_TRACE(
LOG_TRACE(
HW_GPU,
"Loaded default attribute {:x} for vertex {:x} (index {:x}): ({}, {}, {}, {})", i,
vertex, index, input.attr[i][0].ToFloat32(), input.attr[i][1].ToFloat32(),

6
src/video_core/video_core.cpp
View file

@ -31,9 +31,9 @@ bool Init(EmuWindow* emu_window) {
g_renderer = std::make_unique<RendererOpenGL>();
g_renderer->SetWindow(g_emu_window);
if (g_renderer->Init()) {
NGLOG_DEBUG(Render, "initialized OK");
LOG_DEBUG(Render, "initialized OK");
} else {
NGLOG_ERROR(Render, "initialization failed !");
LOG_ERROR(Render, "initialization failed !");
return false;
}
return true;
@ -45,7 +45,7 @@ void Shutdown() {
g_renderer.reset();
NGLOG_DEBUG(Render, "shutdown OK");
LOG_DEBUG(Render, "shutdown OK");
}
} // namespace VideoCore