AvaloniaUI
/
angle
зеркало из https://github.com/AvaloniaUI/angle.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Use C++11 raw string literals instead of SHADER_SOURCE macro 

This is better in many ways:
1. It doesn't confuse clang format
2. \n doesn't need to be included after preprocessor directives like
   the version directive.
3. It's using built-in functionality instead of something custom.

Raw string literals should be the preferred way to include shader
source in C++ files going forward.

BUG=angleproject:2157
TEST=angle_end2end_tests

Change-Id: I8b236a6e2d5c25d920297e5bc5b5b143eddeba1f
Reviewed-on: https://chromium-review.googlesource.com/671046
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
This commit is contained in:
Olli Etuaho 2017-09-18 13:32:29 +03:00 коммит произвёл Commit Bot
Родитель bb5a7e29d2
Коммит a20af6d7e8
54 изменённых файлов: 672 добавлений и 925 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

16
samples/hello_triangle/HelloTriangle.cpp
Просмотреть файл

@ -26,23 +26,19 @@ class HelloTriangleSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 vPosition;
attribute vec4 vPosition;
void main() void main()
{ {
gl_Position = vPosition; gl_Position = vPosition;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/mip_map_2d/MipMap2D.cpp
Просмотреть файл

@ -27,9 +27,8 @@ class MipMap2DSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(uniform float u_offset;
uniform float u_offset;
attribute vec4 a_position; attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
varying vec2 v_texCoord; varying vec2 v_texCoord;
@ -38,19 +37,16 @@ class MipMap2DSample : public SampleApplication
gl_Position = a_position; gl_Position = a_position;
gl_Position.x += u_offset; gl_Position.x += u_offset;
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_texture; uniform sampler2D s_texture;
void main() void main()
{ {
gl_FragColor = texture2D(s_texture, v_texCoord); gl_FragColor = texture2D(s_texture, v_texCoord);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/multi_texture/MultiTexture.cpp
Просмотреть файл

@ -40,21 +40,18 @@ class MultiTextureSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
varying vec2 v_texCoord; varying vec2 v_texCoord;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_baseMap; uniform sampler2D s_baseMap;
uniform sampler2D s_lightMap; uniform sampler2D s_lightMap;
@ -66,8 +63,7 @@ class MultiTextureSample : public SampleApplication
baseColor = texture2D(s_baseMap, v_texCoord); baseColor = texture2D(s_baseMap, v_texCoord);
lightColor = texture2D(s_lightMap, v_texCoord); lightColor = texture2D(s_lightMap, v_texCoord);
gl_FragColor = baseColor * (lightColor + 0.25); gl_FragColor = baseColor * (lightColor + 0.25);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/multi_window/MultiWindow.cpp
Просмотреть файл

@ -26,23 +26,19 @@ class MultiWindowSample : public SampleApplication
bool initialize() override bool initialize() override
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 vPosition;
attribute vec4 vPosition;
void main() void main()
{ {
gl_Position = vPosition; gl_Position = vPosition;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/particle_system/ParticleSystem.cpp
Просмотреть файл

@ -36,9 +36,8 @@ class ParticleSystemSample : public SampleApplication
bool initialize() override bool initialize() override
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(uniform float u_time;
uniform float u_time;
uniform vec3 u_centerPosition; uniform vec3 u_centerPosition;
attribute float a_lifetime; attribute float a_lifetime;
attribute vec3 a_startPosition; attribute vec3 a_startPosition;
@ -59,12 +58,10 @@ class ParticleSystemSample : public SampleApplication
v_lifetime = 1.0 - (u_time / a_lifetime); v_lifetime = 1.0 - (u_time / a_lifetime);
v_lifetime = clamp(v_lifetime, 0.0, 1.0); v_lifetime = clamp(v_lifetime, 0.0, 1.0);
gl_PointSize = (v_lifetime * v_lifetime) * 40.0; gl_PointSize = (v_lifetime * v_lifetime) * 40.0;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_color; uniform vec4 u_color;
varying float v_lifetime; varying float v_lifetime;
uniform sampler2D s_texture; uniform sampler2D s_texture;
@ -74,8 +71,7 @@ class ParticleSystemSample : public SampleApplication
texColor = texture2D(s_texture, gl_PointCoord); texColor = texture2D(s_texture, gl_PointCoord);
gl_FragColor = vec4(u_color) * texColor; gl_FragColor = vec4(u_color) * texColor;
gl_FragColor.a *= v_lifetime; gl_FragColor.a *= v_lifetime;
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/post_sub_buffer/PostSubBuffer.cpp
Просмотреть файл

@ -39,9 +39,8 @@ class PostSubBufferSample : public SampleApplication
return false; return false;
} }
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(uniform mat4 u_mvpMatrix;
uniform mat4 u_mvpMatrix;
attribute vec4 a_position; attribute vec4 a_position;
attribute vec2 a_texcoord; attribute vec2 a_texcoord;
varying vec2 v_texcoord; varying vec2 v_texcoord;
@ -49,18 +48,15 @@ class PostSubBufferSample : public SampleApplication
{ {
gl_Position = u_mvpMatrix * a_position; gl_Position = u_mvpMatrix * a_position;
v_texcoord = a_texcoord; v_texcoord = a_texcoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texcoord; varying vec2 v_texcoord;
void main() void main()
{ {
gl_FragColor = vec4(v_texcoord.x, v_texcoord.y, 1.0, 1.0); gl_FragColor = vec4(v_texcoord.x, v_texcoord.y, 1.0, 1.0);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/simple_instancing/SimpleInstancing.cpp
Просмотреть файл

@ -50,9 +50,8 @@ class SimpleInstancingSample : public SampleApplication
return false; return false;
} }
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec3 a_position;
attribute vec3 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
attribute vec3 a_instancePos; attribute vec3 a_instancePos;
varying vec2 v_texCoord; varying vec2 v_texCoord;
@ -60,19 +59,16 @@ class SimpleInstancingSample : public SampleApplication
{ {
gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0); gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0);
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_texture; uniform sampler2D s_texture;
void main() void main()
{ {
gl_FragColor = texture2D(s_texture, v_texCoord); gl_FragColor = texture2D(s_texture, v_texCoord);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/simple_texture_2d/SimpleTexture2D.cpp
Просмотреть файл

@ -27,28 +27,24 @@ class SimpleTexture2DSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
varying vec2 v_texCoord; varying vec2 v_texCoord;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_texture; uniform sampler2D s_texture;
void main() void main()
{ {
gl_FragColor = texture2D(s_texture, v_texCoord); gl_FragColor = texture2D(s_texture, v_texCoord);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/simple_texture_cubemap/SimpleTextureCubemap.cpp
Просмотреть файл

@ -28,28 +28,24 @@ class SimpleTextureCubemapSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
attribute vec3 a_normal; attribute vec3 a_normal;
varying vec3 v_normal; varying vec3 v_normal;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
v_normal = a_normal; v_normal = a_normal;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec3 v_normal; varying vec3 v_normal;
uniform samplerCube s_texture; uniform samplerCube s_texture;
void main() void main()
{ {
gl_FragColor = textureCube(s_texture, v_normal); gl_FragColor = textureCube(s_texture, v_normal);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/simple_vertex_shader/SimpleVertexShader.cpp
Просмотреть файл

@ -32,9 +32,8 @@ class SimpleVertexShaderSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(uniform mat4 u_mvpMatrix;
uniform mat4 u_mvpMatrix;
attribute vec4 a_position; attribute vec4 a_position;
attribute vec2 a_texcoord; attribute vec2 a_texcoord;
varying vec2 v_texcoord; varying vec2 v_texcoord;
@ -42,18 +41,15 @@ class SimpleVertexShaderSample : public SampleApplication
{ {
gl_Position = u_mvpMatrix * a_position; gl_Position = u_mvpMatrix * a_position;
v_texcoord = a_texcoord; v_texcoord = a_texcoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texcoord; varying vec2 v_texcoord;
void main() void main()
{ {
gl_FragColor = vec4(v_texcoord.x, v_texcoord.y, 1.0, 1.0); gl_FragColor = vec4(v_texcoord.x, v_texcoord.y, 1.0, 1.0);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/stencil_operations/StencilOperations.cpp
Просмотреть файл

@ -26,24 +26,20 @@ class StencilOperationsSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_color; uniform vec4 u_color;
void main() void main()
{ {
gl_FragColor = u_color; gl_FragColor = u_color;
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/tex_redef_microbench/TexRedefMicroBench.cpp
Просмотреть файл

@ -88,28 +88,24 @@ class TexRedefBenchSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
varying vec2 v_texCoord; varying vec2 v_texCoord;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_texture; uniform sampler2D s_texture;
void main() void main()
{ {
gl_FragColor = texture2D(s_texture, v_texCoord); gl_FragColor = texture2D(s_texture, v_texCoord);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/texture_wrap/TextureWrap.cpp
Просмотреть файл

@ -27,9 +27,8 @@ class TextureWrapSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(uniform float u_offset;
uniform float u_offset;
attribute vec4 a_position; attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
varying vec2 v_texCoord; varying vec2 v_texCoord;
@ -38,19 +37,16 @@ class TextureWrapSample : public SampleApplication
gl_Position = a_position; gl_Position = a_position;
gl_Position.x += u_offset; gl_Position.x += u_offset;
v_texCoord = a_texCoord; v_texCoord = a_texCoord;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
varying vec2 v_texCoord; varying vec2 v_texCoord;
uniform sampler2D s_texture; uniform sampler2D s_texture;
void main() void main()
{ {
gl_FragColor = texture2D(s_texture, v_texCoord); gl_FragColor = texture2D(s_texture, v_texCoord);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

16
samples/tri_fan_microbench/TriFanMicroBench.cpp
Просмотреть файл

@ -134,23 +134,19 @@ class TriangleFanBenchSample : public SampleApplication
virtual bool initialize() virtual bool initialize()
{ {
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(attribute vec4 vPosition;
attribute vec4 vPosition;
void main() void main()
{ {
gl_Position = vPosition; gl_Position = vPosition;
} })";
);
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
if (!mProgram) if (!mProgram)

26
src/tests/egl_tests/EGLPresentPathD3D11Test.cpp
Просмотреть файл

@ -183,21 +183,25 @@ class EGLPresentPathD3D11 : public testing::TestWithParam<PlatformParameters>
GLint mTexture2DUniformLocation; GLint mTexture2DUniformLocation;
const std::string vertexShaderSource = const std::string vertexShaderSource =
SHADER_SOURCE(precision highp float; attribute vec4 position; varying vec2 texcoord; R"(precision highp float;
attribute vec4 position;
varying vec2 texcoord;
void main() void main()
{ {
gl_Position = vec4(position.xy, 0.0, 1.0); gl_Position = vec4(position.xy, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
}); })";
const std::string fragmentShaderSource2D = const std::string fragmentShaderSource2D =
SHADER_SOURCE(precision highp float; uniform sampler2D tex; varying vec2 texcoord; R"(precision highp float;
uniform sampler2D tex;
varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
}); })";
m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D); m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D);
mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex"); mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex");

16
src/tests/egl_tests/EGLSurfaceTest.cpp
Просмотреть файл

@ -167,23 +167,19 @@ class EGLSurfaceTest : public testing::Test
GLuint createProgram() GLuint createProgram()
{ {
const std::string testVertexShaderSource = SHADER_SOURCE const std::string testVertexShaderSource =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string testFragmentShaderSource = SHADER_SOURCE const std::string testFragmentShaderSource =
( R"(void main(void)
void main(void)
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
return CompileProgram(testVertexShaderSource, testFragmentShaderSource); return CompileProgram(testVertexShaderSource, testFragmentShaderSource);
} }

108
src/tests/gl_tests/BindUniformLocationTest.cpp
Просмотреть файл

@ -64,28 +64,22 @@ TEST_P(BindUniformLocationTest, Basic)
ASSERT_NE(mBindUniformLocation, nullptr); ASSERT_NE(mBindUniformLocation, nullptr);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(attribute vec4 a_position;
(
attribute vec4 a_position;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_colorC; uniform vec4 u_colorC;
uniform vec4 u_colorB[2]; uniform vec4 u_colorB[2];
uniform vec4 u_colorA; uniform vec4 u_colorA;
void main() void main()
{ {
gl_FragColor = u_colorA + u_colorB[0] + u_colorB[1] + u_colorC; gl_FragColor = u_colorA + u_colorB[0] + u_colorB[1] + u_colorC;
} })";
);
// clang-format on
GLint colorALocation = 3; GLint colorALocation = 3;
GLint colorBLocation = 10; GLint colorBLocation = 10;
@ -141,27 +135,21 @@ TEST_P(BindUniformLocationTest, ConflictsDetection)
ASSERT_NE(nullptr, mBindUniformLocation); ASSERT_NE(nullptr, mBindUniformLocation);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(attribute vec4 a_position;
(
attribute vec4 a_position;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_colorA; uniform vec4 u_colorA;
uniform vec4 u_colorB; uniform vec4 u_colorB;
void main() void main()
{ {
gl_FragColor = u_colorA + u_colorB; gl_FragColor = u_colorA + u_colorB;
} })";
);
// clang-format on
GLint colorALocation = 3; GLint colorALocation = 3;
GLint colorBLocation = 4; GLint colorBLocation = 4;
@ -203,10 +191,8 @@ TEST_P(BindUniformLocationTest, Compositor)
ASSERT_NE(nullptr, mBindUniformLocation); ASSERT_NE(nullptr, mBindUniformLocation);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(attribute vec4 a_position;
(
attribute vec4 a_position;
attribute vec2 a_texCoord; attribute vec2 a_texCoord;
uniform mat4 matrix; uniform mat4 matrix;
uniform vec2 color_a[4]; uniform vec2 color_a[4];
@ -218,12 +204,10 @@ TEST_P(BindUniformLocationTest, Compositor)
v_color.zw = color_a[2] + color_a[3]; v_color.zw = color_a[2] + color_a[3];
v_color += color_b; v_color += color_b;
gl_Position = matrix * a_position; gl_Position = matrix * a_position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
varying vec4 v_color; varying vec4 v_color;
uniform float alpha; uniform float alpha;
uniform vec4 multiplier; uniform vec4 multiplier;
@ -242,9 +226,7 @@ TEST_P(BindUniformLocationTest, Compositor)
color_c_sum.w = alpha; color_c_sum.w = alpha;
color_c_sum *= multiplier; color_c_sum *= multiplier;
gl_FragColor = v_color + color_c_sum; gl_FragColor = v_color + color_c_sum;
} })";
);
// clang-format on
int counter = 6; int counter = 6;
int matrixLocation = counter++; int matrixLocation = counter++;
@ -319,28 +301,22 @@ TEST_P(BindUniformLocationTest, UnusedUniformUpdate)
ASSERT_NE(nullptr, mBindUniformLocation); ASSERT_NE(nullptr, mBindUniformLocation);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(attribute vec4 a_position;
(
attribute vec4 a_position;
void main() void main()
{ {
gl_Position = a_position; gl_Position = a_position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_colorA; uniform vec4 u_colorA;
uniform float u_colorU; uniform float u_colorU;
uniform vec4 u_colorC; uniform vec4 u_colorC;
void main() void main()
{ {
gl_FragColor = u_colorA + u_colorC; gl_FragColor = u_colorA + u_colorC;
} })";
);
// clang-format on
const GLint colorULocation = 1; const GLint colorULocation = 1;
const GLint nonexistingLocation = 5; const GLint nonexistingLocation = 5;
@ -430,24 +406,18 @@ TEST_P(BindUniformLocationTest, UseSamplerWhenUnusedUniforms)
ASSERT_NE(nullptr, mBindUniformLocation); ASSERT_NE(nullptr, mBindUniformLocation);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(void main()
(
void main()
{ {
gl_Position = vec4(0); gl_Position = vec4(0);
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(uniform sampler2D tex;
uniform sampler2D tex;
void main() void main()
{ {
gl_FragColor = texture2D(tex, vec2(1)); gl_FragColor = texture2D(tex, vec2(1));
} })";
);
// clang-format on
const GLuint texLocation = 54; const GLuint texLocation = 54;
@ -485,26 +455,20 @@ TEST_P(BindUniformLocationTest, SameLocationForUsedAndUnusedUniform)
ASSERT_NE(nullptr, mBindUniformLocation); ASSERT_NE(nullptr, mBindUniformLocation);
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(void main()
(
void main()
{ {
gl_Position = vec4(0); gl_Position = vec4(0);
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
uniform vec4 a; uniform vec4 a;
uniform vec4 b; uniform vec4 b;
void main() void main()
{ {
gl_FragColor = a; gl_FragColor = a;
} })";
);
// clang-format on
const GLuint location = 54; const GLuint location = 54;

17
src/tests/gl_tests/BlendMinMaxTest.cpp
Просмотреть файл

@ -123,24 +123,19 @@ class BlendMinMaxTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string testVertexShaderSource = SHADER_SOURCE const std::string testVertexShaderSource =
( R"(attribute highp vec4 aPosition;
attribute highp vec4 aPosition;
void main(void) void main(void)
{ {
gl_Position = aPosition; gl_Position = aPosition;
} })";
);
const std::string testFragmentShaderSource = SHADER_SOURCE const std::string testFragmentShaderSource =
( R"(uniform highp vec4 color;
uniform highp vec4 color;
void main(void) void main(void)
{ {
gl_FragColor = color; gl_FragColor = color;
} })";
);
mProgram = CompileProgram(testVertexShaderSource, testFragmentShaderSource); mProgram = CompileProgram(testVertexShaderSource, testFragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

24
src/tests/gl_tests/BlitFramebufferANGLETest.cpp
Просмотреть файл

@ -65,9 +65,8 @@ class BlitFramebufferANGLETest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string passthroughVS = SHADER_SOURCE const std::string passthroughVS =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec4 pos; varying vec4 pos;
@ -75,12 +74,10 @@ class BlitFramebufferANGLETest : public ANGLETest
{ {
gl_Position = position; gl_Position = position;
pos = position; pos = position;
} })";
);
const std::string checkeredFS = SHADER_SOURCE const std::string checkeredFS =
( R"(precision highp float;
precision highp float;
varying vec4 pos; varying vec4 pos;
void main() void main()
@ -93,19 +90,16 @@ class BlitFramebufferANGLETest : public ANGLETest
{ {
gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
} }
} })";
);
const std::string blueFS = SHADER_SOURCE const std::string blueFS =
( R"(precision highp float;
precision highp float;
varying vec4 pos; varying vec4 pos;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0); gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
} })";
);
mCheckerProgram = CompileProgram(passthroughVS, checkeredFS); mCheckerProgram = CompileProgram(passthroughVS, checkeredFS);
mBlueProgram = CompileProgram(passthroughVS, blueFS); mBlueProgram = CompileProgram(passthroughVS, blueFS);

32
src/tests/gl_tests/BufferDataTest.cpp
Просмотреть файл

@ -35,27 +35,23 @@ class BufferDataTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const char * vsSource = SHADER_SOURCE const char *vsSource =
( R"(attribute vec4 position;
attribute vec4 position;
attribute float in_attrib; attribute float in_attrib;
varying float v_attrib; varying float v_attrib;
void main() void main()
{ {
v_attrib = in_attrib; v_attrib = in_attrib;
gl_Position = position; gl_Position = position;
} })";
);
const char * fsSource = SHADER_SOURCE const char *fsSource =
( R"(precision mediump float;
precision mediump float;
varying float v_attrib; varying float v_attrib;
void main() void main()
{ {
gl_FragColor = vec4(v_attrib, 0, 0, 1); gl_FragColor = vec4(v_attrib, 0, 0, 1);
} })";
);
glGenBuffers(1, &mBuffer); glGenBuffers(1, &mBuffer);
ASSERT_NE(mBuffer, 0U); ASSERT_NE(mBuffer, 0U);
@ -253,27 +249,23 @@ class IndexedBufferCopyTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const char * vsSource = SHADER_SOURCE const char *vsSource =
( R"(attribute vec3 in_attrib;
attribute vec3 in_attrib;
varying vec3 v_attrib; varying vec3 v_attrib;
void main() void main()
{ {
v_attrib = in_attrib; v_attrib = in_attrib;
gl_Position = vec4(0.0, 0.0, 0.5, 1.0); gl_Position = vec4(0.0, 0.0, 0.5, 1.0);
gl_PointSize = 100.0; gl_PointSize = 100.0;
} })";
);
const char * fsSource = SHADER_SOURCE const char *fsSource =
( R"(precision mediump float;
precision mediump float;
varying vec3 v_attrib; varying vec3 v_attrib;
void main() void main()
{ {
gl_FragColor = vec4(v_attrib, 1); gl_FragColor = vec4(v_attrib, 1);
} })";
);
glGenBuffers(2, mBuffers); glGenBuffers(2, mBuffers);
ASSERT_NE(mBuffers[0], 0U); ASSERT_NE(mBuffers[0], 0U);

16
src/tests/gl_tests/ClearTest.cpp
Просмотреть файл

@ -75,26 +75,22 @@ class ClearTestBase : public ANGLETest
void setupDefaultProgram() void setupDefaultProgram()
{ {
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);

16
src/tests/gl_tests/CubeMapTextureTest.cpp
Просмотреть файл

@ -25,23 +25,19 @@ class CubeMapTextureTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(uniform highp vec4 color;
uniform highp vec4 color;
void main(void) void main(void)
{ {
gl_FragColor = color; gl_FragColor = color;
} })";
);
mProgram = CompileProgram(vsSource, fsSource); mProgram = CompileProgram(vsSource, fsSource);
if (mProgram == 0) if (mProgram == 0)

16
src/tests/gl_tests/D3DImageFormatConversionTest.cpp
Просмотреть файл

@ -32,9 +32,8 @@ class D3DImageFormatConversionTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -42,20 +41,17 @@ class D3DImageFormatConversionTest : public ANGLETest
{ {
gl_Position = vec4(position.xy, 0.0, 1.0); gl_Position = vec4(position.xy, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string fragmentShaderSource2D = SHADER_SOURCE const std::string fragmentShaderSource2D =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D); m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D);
mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex"); mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex");

26
src/tests/gl_tests/D3DTextureTest.cpp
Просмотреть файл

@ -36,10 +36,8 @@ class D3DTextureTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
// clang-format off const std::string vsSource =
const std::string vsSource = SHADER_SOURCE R"(precision highp float;
(
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -48,31 +46,25 @@ class D3DTextureTest : public ANGLETest
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
texcoord.y = 1.0 - texcoord.y; texcoord.y = 1.0 - texcoord.y;
} })";
);
const std::string textureFSSource = SHADER_SOURCE const std::string textureFSSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
const std::string textureFSSourceNoSampling = SHADER_SOURCE const std::string textureFSSourceNoSampling =
( R"(precision highp float;
precision highp float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
} })";
);
// clang-format on
mTextureProgram = CompileProgram(vsSource, textureFSSource); mTextureProgram = CompileProgram(vsSource, textureFSSource);
ASSERT_NE(0u, mTextureProgram) << "shader compilation failed."; ASSERT_NE(0u, mTextureProgram) << "shader compilation failed.";

16
src/tests/gl_tests/DXT1CompressedTextureTest.cpp
Просмотреть файл

@ -28,9 +28,8 @@ class DXT1CompressedTextureTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -39,20 +38,17 @@ class DXT1CompressedTextureTest : public ANGLETest
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
texcoord.y = 1.0 - texcoord.y; texcoord.y = 1.0 - texcoord.y;
} })";
);
const std::string textureFSSource = SHADER_SOURCE const std::string textureFSSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
mTextureProgram = CompileProgram(vsSource, textureFSSource); mTextureProgram = CompileProgram(vsSource, textureFSSource);
if (mTextureProgram == 0) if (mTextureProgram == 0)

16
src/tests/gl_tests/DepthStencilFormatsTest.cpp
Просмотреть файл

@ -68,9 +68,8 @@ class DepthStencilFormatsTestBase : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -78,20 +77,17 @@ class DepthStencilFormatsTestBase : public ANGLETest
{ {
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

32
src/tests/gl_tests/DifferentStencilMasksTest.cpp
Просмотреть файл

@ -32,26 +32,22 @@ class DifferentStencilMasksTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0); gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);
@ -118,26 +114,22 @@ class DifferentStencilMasksWithoutStencilBufferTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0); gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);

16
src/tests/gl_tests/FramebufferRenderMipmapTest.cpp
Просмотреть файл

@ -25,23 +25,19 @@ class FramebufferRenderMipmapTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(uniform highp vec4 color;
uniform highp vec4 color;
void main(void) void main(void)
{ {
gl_FragColor = color; gl_FragColor = color;
} })";
);
mProgram = CompileProgram(vsSource, fsSource); mProgram = CompileProgram(vsSource, fsSource);
if (mProgram == 0) if (mProgram == 0)

113
src/tests/gl_tests/GLSLTest.cpp
Просмотреть файл

@ -30,14 +30,12 @@ class GLSLTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
mSimpleVSSource = SHADER_SOURCE mSimpleVSSource =
( R"(attribute vec4 inputAttribute;
attribute vec4 inputAttribute;
void main() void main()
{ {
gl_Position = inputAttribute; gl_Position = inputAttribute;
} })";
);
} }
std::string GenerateVaryingType(GLint vectorSize) std::string GenerateVaryingType(GLint vectorSize)
@ -449,12 +447,12 @@ class GLSLTest_ES3 : public GLSLTest
ANGLETest::SetUp(); ANGLETest::SetUp();
mSimpleVSSource = mSimpleVSSource =
"#version 300 es\n" R"(#version 300 es
"in vec4 inputAttribute;" in vec4 inputAttribute;
"void main()" void main()
"{" {
" gl_Position = inputAttribute;" gl_Position = inputAttribute;
"}"; })";
} }
}; };
@ -465,21 +463,19 @@ class GLSLTest_ES31 : public GLSLTest
ANGLETest::SetUp(); ANGLETest::SetUp();
mSimpleVSSource = mSimpleVSSource =
"#version 310 es\n" R"(#version 310 es
"in vec4 inputAttribute;" in vec4 inputAttribute;
"void main()" void main()
"{" {
" gl_Position = inputAttribute;" gl_Position = inputAttribute;
"}"; })";
} }
}; };
TEST_P(GLSLTest, NamelessScopedStructs) TEST_P(GLSLTest, NamelessScopedStructs)
{ {
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
struct struct
@ -489,8 +485,7 @@ TEST_P(GLSLTest, NamelessScopedStructs)
gl_FragColor = vec4(1, 0, 0, 1); gl_FragColor = vec4(1, 0, 0, 1);
gl_FragColor.a += b.q; gl_FragColor.a += b.q;
} })";
);
GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource); GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
EXPECT_NE(0u, program); EXPECT_NE(0u, program);
@ -508,9 +503,8 @@ TEST_P(GLSLTest, ScopedStructsOrderBug)
return; return;
} }
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
struct T struct T
{ {
@ -531,8 +525,7 @@ TEST_P(GLSLTest, ScopedStructsOrderBug)
gl_FragColor = vec4(1, 0, 0, 1); gl_FragColor = vec4(1, 0, 0, 1);
gl_FragColor.a += a.f; gl_FragColor.a += a.f;
gl_FragColor.a += b.q; gl_FragColor.a += b.q;
} })";
);
GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource); GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
EXPECT_NE(0u, program); EXPECT_NE(0u, program);
@ -540,9 +533,8 @@ TEST_P(GLSLTest, ScopedStructsOrderBug)
TEST_P(GLSLTest, ScopedStructsBug) TEST_P(GLSLTest, ScopedStructsBug)
{ {
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
struct T_0 struct T_0
{ {
@ -563,8 +555,7 @@ TEST_P(GLSLTest, ScopedStructsBug)
gl_FragColor.a += a.f; gl_FragColor.a += a.f;
gl_FragColor.a += b.v.x; gl_FragColor.a += b.v.x;
} })";
);
GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource); GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
EXPECT_NE(0u, program); EXPECT_NE(0u, program);
@ -572,28 +563,24 @@ TEST_P(GLSLTest, ScopedStructsBug)
TEST_P(GLSLTest, DxPositionBug) TEST_P(GLSLTest, DxPositionBug)
{ {
const std::string &vertexShaderSource = SHADER_SOURCE const std::string &vertexShaderSource =
( R"(attribute vec4 inputAttribute;
attribute vec4 inputAttribute;
varying float dx_Position; varying float dx_Position;
void main() void main()
{ {
gl_Position = vec4(inputAttribute); gl_Position = vec4(inputAttribute);
dx_Position = 0.0; dx_Position = 0.0;
} })";
);
const std::string &fragmentShaderSource = SHADER_SOURCE const std::string &fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
varying float dx_Position; varying float dx_Position;
void main() void main()
{ {
gl_FragColor = vec4(dx_Position, 0, 0, 1); gl_FragColor = vec4(dx_Position, 0, 0, 1);
} })";
);
GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource); GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
EXPECT_NE(0u, program); EXPECT_NE(0u, program);
@ -664,20 +651,17 @@ TEST_P(GLSLTest, FrontFacingAndVarying)
{ {
EGLPlatformParameters platform = GetParam().eglParameters; EGLPlatformParameters platform = GetParam().eglParameters;
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(attribute vec4 a_position;
attribute vec4 a_position;
varying float v_varying; varying float v_varying;
void main() void main()
{ {
v_varying = a_position.x; v_varying = a_position.x;
gl_Position = a_position; gl_Position = a_position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
varying float v_varying; varying float v_varying;
void main() void main()
{ {
@ -692,8 +676,7 @@ TEST_P(GLSLTest, FrontFacingAndVarying)
c = vec4(0, v_varying, 0, 1.0); c = vec4(0, v_varying, 0, 1.0);
} }
gl_FragColor = c; gl_FragColor = c;
} })";
);
GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource); GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
@ -1570,9 +1553,8 @@ TEST_P(GLSLTest, BadIndexBug)
// Test that structs defined in uniforms are translated correctly. // Test that structs defined in uniforms are translated correctly.
TEST_P(GLSLTest, StructSpecifiersUniforms) TEST_P(GLSLTest, StructSpecifiersUniforms)
{ {
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
uniform struct S { float field;} s; uniform struct S { float field;} s;
@ -1580,8 +1562,7 @@ TEST_P(GLSLTest, StructSpecifiersUniforms)
{ {
gl_FragColor = vec4(1, 0, 0, 1); gl_FragColor = vec4(1, 0, 0, 1);
gl_FragColor.a += s.field; gl_FragColor.a += s.field;
} })";
);
GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource); GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
EXPECT_NE(0u, program); EXPECT_NE(0u, program);
@ -1593,15 +1574,13 @@ TEST_P(GLSLTest, StructSpecifiersUniforms)
// (note this test is still Impl-independent) // (note this test is still Impl-independent)
TEST_P(GLSLTestNoValidation, DepthRangeUniforms) TEST_P(GLSLTestNoValidation, DepthRangeUniforms)
{ {
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff, 1); gl_FragColor = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff, 1);
} })";
);
ANGLE_GL_PROGRAM(program, mSimpleVSSource, fragmentShaderSource); ANGLE_GL_PROGRAM(program, mSimpleVSSource, fragmentShaderSource);
@ -1683,9 +1662,8 @@ TEST_P(GLSLTest, PowOfSmallConstant)
// than FL9_3. // than FL9_3.
TEST_P(GLSLTest, LoopIndexingValidation) TEST_P(GLSLTest, LoopIndexingValidation)
{ {
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision mediump float;
precision mediump float;
uniform float loopMax; uniform float loopMax;
@ -1699,8 +1677,7 @@ TEST_P(GLSLTest, LoopIndexingValidation)
gl_FragColor.a += 0.1; gl_FragColor.a += 0.1;
} }
} }
} })";
);
GLuint shader = glCreateShader(GL_FRAGMENT_SHADER); GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);

16
src/tests/gl_tests/IncompleteTextureTest.cpp
Просмотреть файл

@ -28,9 +28,8 @@ class IncompleteTextureTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -38,20 +37,17 @@ class IncompleteTextureTest : public ANGLETest
{ {
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

16
src/tests/gl_tests/IndexBufferOffsetTest.cpp
Просмотреть файл

@ -29,14 +29,22 @@ class IndexBufferOffsetTest : public ANGLETest
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = const std::string vertexShaderSource =
SHADER_SOURCE(precision highp float; attribute vec2 position; R"(precision highp float;
attribute vec2 position;
void main() { gl_Position = vec4(position, 0.0, 1.0); }); void main()
{
gl_Position = vec4(position, 0.0, 1.0);
})";
const std::string fragmentShaderSource = const std::string fragmentShaderSource =
SHADER_SOURCE(precision highp float; uniform vec4 color; R"(precision highp float;
uniform vec4 color;
void main() { gl_FragColor = color; }); void main()
{
gl_FragColor = color;
})";
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);

43
src/tests/gl_tests/IndexedPointsTest.cpp
Просмотреть файл

@ -32,34 +32,45 @@ class IndexedPointsTest : public ANGLETest
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = const std::string vertexShaderSource =
SHADER_SOURCE(precision highp float; attribute vec2 position; R"(precision highp float;
attribute vec2 position;
void main() { void main() {
gl_PointSize = 5.0; gl_PointSize = 5.0;
gl_Position = vec4(position, 0.0, 1.0); gl_Position = vec4(position, 0.0, 1.0);
}); })";
const std::string fragmentShaderSource = const std::string fragmentShaderSource =
SHADER_SOURCE(precision highp float; R"(precision highp float;
void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }); void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);
const std::string vertexShaderSource2 = const std::string vertexShaderSource2 =
SHADER_SOURCE(precision highp float; attribute vec2 position; attribute vec4 color; R"(precision highp float;
varying vec4 vcolor; attribute vec2 position;
attribute vec4 color;
varying vec4 vcolor;
void main() { void main() {
gl_PointSize = 5.0; gl_PointSize = 5.0;
gl_Position = vec4(position, 0.0, 1.0); gl_Position = vec4(position, 0.0, 1.0);
vcolor = color; vcolor = color;
}); })";
const std::string fragmentShaderSource2 = const std::string fragmentShaderSource2 =
SHADER_SOURCE(precision highp float; varying vec4 vcolor; R"(precision highp float;
void main() { gl_FragColor = vec4(vcolor.xyz, 1.0); }); varying vec4 vcolor;
void main()
{
gl_FragColor = vec4(vcolor.xyz, 1.0);
})";
mVertexWithColorBufferProgram = CompileProgram(vertexShaderSource2, fragmentShaderSource2); mVertexWithColorBufferProgram = CompileProgram(vertexShaderSource2, fragmentShaderSource2);
ASSERT_NE(0u, mVertexWithColorBufferProgram); ASSERT_NE(0u, mVertexWithColorBufferProgram);

15
src/tests/gl_tests/LineLoopTest.cpp
Просмотреть файл

@ -25,12 +25,19 @@ class LineLoopTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE(attribute highp vec4 position; const std::string vsSource =
R"(attribute highp vec4 position;
void main(void) { gl_Position = position; }); void main(void)
{
gl_Position = position;
})";
const std::string fsSource = const std::string fsSource =
SHADER_SOURCE(uniform highp vec4 color; void main(void) { gl_FragColor = color; }); R"(uniform highp vec4 color;
void main(void)
{
gl_FragColor = color;
})";
mProgram = CompileProgram(vsSource, fsSource); mProgram = CompileProgram(vsSource, fsSource);
if (mProgram == 0) if (mProgram == 0)

24
src/tests/gl_tests/MaxTextureSizeTest.cpp
Просмотреть файл

@ -25,9 +25,8 @@ class MaxTextureSizeTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -35,30 +34,25 @@ class MaxTextureSizeTest : public ANGLETest
{ {
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string textureFSSource = SHADER_SOURCE const std::string textureFSSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
const std::string blueFSSource = SHADER_SOURCE const std::string blueFSSource =
( R"(precision highp float;
precision highp float;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0); gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);
} })";
);
mTextureProgram = CompileProgram(vsSource, textureFSSource); mTextureProgram = CompileProgram(vsSource, textureFSSource);
mBlueProgram = CompileProgram(vsSource, blueFSSource); mBlueProgram = CompileProgram(vsSource, blueFSSource);

77
src/tests/gl_tests/MipmapTest.cpp
Просмотреть файл

@ -75,23 +75,19 @@ class MipmapTest : public BaseMipmapTest
void setUp2DProgram() void setUp2DProgram()
{ {
// Vertex Shader source // Vertex Shader source
// clang-format off const std::string vs =
const std::string vs = SHADER_SOURCE R"(attribute vec4 position;
(
attribute vec4 position;
varying vec2 vTexCoord; varying vec2 vTexCoord;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
vTexCoord = (position.xy * 0.5) + 0.5; vTexCoord = (position.xy * 0.5) + 0.5;
} })";
);
// Fragment Shader source // Fragment Shader source
const std::string fs = SHADER_SOURCE const std::string fs =
( R"(precision mediump float;
precision mediump float;
uniform sampler2D uTexture; uniform sampler2D uTexture;
varying vec2 vTexCoord; varying vec2 vTexCoord;
@ -99,9 +95,7 @@ class MipmapTest : public BaseMipmapTest
void main() void main()
{ {
gl_FragColor = texture2D(uTexture, vTexCoord); gl_FragColor = texture2D(uTexture, vTexCoord);
} })";
);
// clang-format on
m2DProgram = CompileProgram(vs, fs); m2DProgram = CompileProgram(vs, fs);
ASSERT_NE(0u, m2DProgram); ASSERT_NE(0u, m2DProgram);
@ -110,31 +104,25 @@ class MipmapTest : public BaseMipmapTest
void setUpCubeProgram() void setUpCubeProgram()
{ {
// A simple vertex shader for the texture cube // A simple vertex shader for the texture cube
// clang-format off const std::string cubeVS =
const std::string cubeVS = SHADER_SOURCE R"(attribute vec4 position;
(
attribute vec4 position;
varying vec4 vPosition; varying vec4 vPosition;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
vPosition = position; vPosition = position;
} })";
);
// A very simple fragment shader to sample from the negative-Y face of a texture cube. // A very simple fragment shader to sample from the negative-Y face of a texture cube.
const std::string cubeFS = SHADER_SOURCE const std::string cubeFS =
( R"(precision mediump float;
precision mediump float;
uniform samplerCube uTexture; uniform samplerCube uTexture;
varying vec4 vPosition; varying vec4 vPosition;
void main() void main()
{ {
gl_FragColor = textureCube(uTexture, vec3(vPosition.x, -1, vPosition.y)); gl_FragColor = textureCube(uTexture, vec3(vPosition.x, -1, vPosition.y));
} })";
);
// clang-format on
mCubeProgram = CompileProgram(cubeVS, cubeFS); mCubeProgram = CompileProgram(cubeVS, cubeFS);
ASSERT_NE(0u, mCubeProgram); ASSERT_NE(0u, mCubeProgram);
@ -264,9 +252,8 @@ class MipmapTestES3 : public BaseMipmapTest
// Don't put "#version ..." on its own line. See [cpp]p1: // Don't put "#version ..." on its own line. See [cpp]p1:
// "If there are sequences of preprocessing tokens within the list of arguments that // "If there are sequences of preprocessing tokens within the list of arguments that
// would otherwise act as preprocessing directives, the behavior is undefined" // would otherwise act as preprocessing directives, the behavior is undefined"
// clang-format off return
return SHADER_SOURCE R"(#version 300 es
( #version 300 es\n
precision highp float; precision highp float;
in vec4 position; in vec4 position;
out vec2 texcoord; out vec2 texcoord;
@ -275,15 +262,13 @@ class MipmapTestES3 : public BaseMipmapTest
{ {
gl_Position = vec4(position.xy, 0.0, 1.0); gl_Position = vec4(position.xy, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
// clang-format on
} }
void setUpArrayProgram() void setUpArrayProgram()
{ {
const std::string fragmentShaderSourceArray = SHADER_SOURCE const std::string fragmentShaderSourceArray =
( #version 300 es\n R"(#version 300 es
precision highp float; precision highp float;
uniform highp sampler2DArray tex; uniform highp sampler2DArray tex;
uniform int slice; uniform int slice;
@ -293,8 +278,7 @@ class MipmapTestES3 : public BaseMipmapTest
void main() void main()
{ {
out_FragColor = texture(tex, vec3(texcoord, float(slice))); out_FragColor = texture(tex, vec3(texcoord, float(slice)));
} })";
);
mArrayProgram = CompileProgram(vertexShaderSource(), fragmentShaderSourceArray); mArrayProgram = CompileProgram(vertexShaderSource(), fragmentShaderSourceArray);
if (mArrayProgram == 0) if (mArrayProgram == 0)
@ -312,8 +296,8 @@ class MipmapTestES3 : public BaseMipmapTest
void setUp3DProgram() void setUp3DProgram()
{ {
const std::string fragmentShaderSource3D = SHADER_SOURCE const std::string fragmentShaderSource3D =
( #version 300 es\n R"(#version 300 es
precision highp float; precision highp float;
uniform highp sampler3D tex; uniform highp sampler3D tex;
uniform float slice; uniform float slice;
@ -324,8 +308,7 @@ class MipmapTestES3 : public BaseMipmapTest
void main() void main()
{ {
out_FragColor = textureLod(tex, vec3(texcoord, slice), lod); out_FragColor = textureLod(tex, vec3(texcoord, slice), lod);
} })";
);
m3DProgram = CompileProgram(vertexShaderSource(), fragmentShaderSource3D); m3DProgram = CompileProgram(vertexShaderSource(), fragmentShaderSource3D);
if (m3DProgram == 0) if (m3DProgram == 0)
@ -347,9 +330,8 @@ class MipmapTestES3 : public BaseMipmapTest
void setUp2DProgram() void setUp2DProgram()
{ {
// clang-format off const std::string fragmentShaderSource2D =
const std::string fragmentShaderSource2D = SHADER_SOURCE R"(#version 300 es
( #version 300 es\n
precision highp float; precision highp float;
uniform highp sampler2D tex; uniform highp sampler2D tex;
in vec2 texcoord; in vec2 texcoord;
@ -358,9 +340,7 @@ class MipmapTestES3 : public BaseMipmapTest
void main() void main()
{ {
out_FragColor = texture(tex, texcoord); out_FragColor = texture(tex, texcoord);
} })";
);
// clang-format on
m2DProgram = CompileProgram(vertexShaderSource(), fragmentShaderSource2D); m2DProgram = CompileProgram(vertexShaderSource(), fragmentShaderSource2D);
ASSERT_NE(0u, m2DProgram); ASSERT_NE(0u, m2DProgram);
@ -371,9 +351,8 @@ class MipmapTestES3 : public BaseMipmapTest
void setUpCubeProgram() void setUpCubeProgram()
{ {
// A very simple fragment shader to sample from the negative-Y face of a texture cube. // A very simple fragment shader to sample from the negative-Y face of a texture cube.
// clang-format off const std::string cubeFS =
const std::string cubeFS = SHADER_SOURCE R"(#version 300 es
( #version 300 es\n
precision mediump float; precision mediump float;
uniform samplerCube uTexture; uniform samplerCube uTexture;
in vec2 texcoord; in vec2 texcoord;
@ -382,9 +361,7 @@ class MipmapTestES3 : public BaseMipmapTest
void main() void main()
{ {
out_FragColor = texture(uTexture, vec3(texcoord.x, -1, texcoord.y)); out_FragColor = texture(uTexture, vec3(texcoord.x, -1, texcoord.y));
} })";
);
// clang-format on
mCubeProgram = CompileProgram(vertexShaderSource(), cubeFS); mCubeProgram = CompileProgram(vertexShaderSource(), cubeFS);
ASSERT_NE(0u, mCubeProgram); ASSERT_NE(0u, mCubeProgram);

32
src/tests/gl_tests/OcclusionQueriesTest.cpp
Просмотреть файл

@ -28,23 +28,19 @@ class OcclusionQueriesTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string passthroughVS = SHADER_SOURCE const std::string passthroughVS =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string passthroughPS = SHADER_SOURCE const std::string passthroughPS =
( R"(precision highp float;
precision highp float;
void main(void) void main(void)
{ {
gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
mProgram = CompileProgram(passthroughVS, passthroughPS); mProgram = CompileProgram(passthroughVS, passthroughPS);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);
@ -288,23 +284,19 @@ TEST_P(OcclusionQueriesTest, MultiContext)
eglMakeCurrent(display, surface, surface, context.context); eglMakeCurrent(display, surface, surface, context.context);
const std::string passthroughVS = SHADER_SOURCE const std::string passthroughVS =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string passthroughPS = SHADER_SOURCE const std::string passthroughPS =
( R"(precision highp float;
precision highp float;
void main(void) void main(void)
{ {
gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
context.program = CompileProgram(passthroughVS, passthroughPS); context.program = CompileProgram(passthroughVS, passthroughPS);
ASSERT_NE(context.program, 0u); ASSERT_NE(context.program, 0u);

24
src/tests/gl_tests/PBOExtensionTest.cpp
Просмотреть файл

@ -34,18 +34,24 @@ class PBOExtensionTest : public ANGLETest
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0); glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
const char *vertexShaderSrc = const char *vertexShaderSrc =
SHADER_SOURCE(attribute vec4 aTest; attribute vec2 aPosition; varying vec4 vTest; R"(attribute vec4 aTest;
attribute vec2 aPosition;
varying vec4 vTest;
void main() { void main()
vTest = aTest; {
gl_Position = vec4(aPosition, 0.0, 1.0); vTest = aTest;
gl_PointSize = 1.0; gl_Position = vec4(aPosition, 0.0, 1.0);
}); gl_PointSize = 1.0;
})";
const char *fragmentShaderSrc = const char *fragmentShaderSrc =
SHADER_SOURCE(precision mediump float; varying vec4 vTest; R"(precision mediump float;
varying vec4 vTest;
void main() { gl_FragColor = vTest; }); void main()
{
gl_FragColor = vTest;
})";
mProgram = CompileProgram(vertexShaderSrc, fragmentShaderSrc); mProgram = CompileProgram(vertexShaderSrc, fragmentShaderSrc);

30
src/tests/gl_tests/PackUnpackTest.cpp
Просмотреть файл

@ -32,21 +32,19 @@ class PackUnpackTest : public ANGLETest
ANGLETest::SetUp(); ANGLETest::SetUp();
// Vertex Shader source // Vertex Shader source
const std::string vs = SHADER_SOURCE const std::string vs =
( #version 300 es\n R"(#version 300 es
precision mediump float; precision mediump float;
in vec4 position; in vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
// clang-format off
// Fragment Shader source // Fragment Shader source
const std::string sNormFS = SHADER_SOURCE const std::string sNormFS =
( #version 300 es\n R"(#version 300 es
precision mediump float; precision mediump float;
uniform mediump vec2 v; uniform mediump vec2 v;
layout(location = 0) out mediump vec4 fragColor; layout(location = 0) out mediump vec4 fragColor;
@ -56,12 +54,11 @@ class PackUnpackTest : public ANGLETest
uint u = packSnorm2x16(v); uint u = packSnorm2x16(v);
vec2 r = unpackSnorm2x16(u); vec2 r = unpackSnorm2x16(u);
fragColor = vec4(r, 0.0, 1.0); fragColor = vec4(r, 0.0, 1.0);
} })";
);
// Fragment Shader source // Fragment Shader source
const std::string uNormFS = SHADER_SOURCE const std::string uNormFS =
( #version 300 es\n R"(#version 300 es
precision mediump float; precision mediump float;
uniform mediump vec2 v; uniform mediump vec2 v;
layout(location = 0) out mediump vec4 fragColor; layout(location = 0) out mediump vec4 fragColor;
@ -71,12 +68,11 @@ class PackUnpackTest : public ANGLETest
uint u = packUnorm2x16(v); uint u = packUnorm2x16(v);
vec2 r = unpackUnorm2x16(u); vec2 r = unpackUnorm2x16(u);
fragColor = vec4(r, 0.0, 1.0); fragColor = vec4(r, 0.0, 1.0);
} })";
);
// Fragment Shader source // Fragment Shader source
const std::string halfFS = SHADER_SOURCE const std::string halfFS =
( #version 300 es\n R"(#version 300 es
precision mediump float; precision mediump float;
uniform mediump vec2 v; uniform mediump vec2 v;
layout(location = 0) out mediump vec4 fragColor; layout(location = 0) out mediump vec4 fragColor;
@ -86,9 +82,7 @@ class PackUnpackTest : public ANGLETest
uint u = packHalf2x16(v); uint u = packHalf2x16(v);
vec2 r = unpackHalf2x16(u); vec2 r = unpackHalf2x16(u);
fragColor = vec4(r, 0.0, 1.0); fragColor = vec4(r, 0.0, 1.0);
} })";
);
// clang-format on
mSNormProgram = CompileProgram(vs, sNormFS); mSNormProgram = CompileProgram(vs, sNormFS);
mUNormProgram = CompileProgram(vs, uNormFS); mUNormProgram = CompileProgram(vs, uNormFS);

16
src/tests/gl_tests/PbufferTest.cpp
Просмотреть файл

@ -26,9 +26,8 @@ class PbufferTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -37,20 +36,17 @@ class PbufferTest : public ANGLETest
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
texcoord.y = 1.0 - texcoord.y; texcoord.y = 1.0 - texcoord.y;
} })";
);
const std::string textureFSSource = SHADER_SOURCE const std::string textureFSSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
mTextureProgram = CompileProgram(vsSource, textureFSSource); mTextureProgram = CompileProgram(vsSource, textureFSSource);
if (mTextureProgram == 0) if (mTextureProgram == 0)

138
src/tests/gl_tests/PointSpritesTest.cpp
Просмотреть файл

@ -52,15 +52,21 @@ TEST_P(PointSpritesTest, PointCoordAndPointSizeCompliance)
return; return;
} }
const std::string fs = SHADER_SOURCE(precision mediump float; void main() { const std::string fs =
gl_FragColor = vec4(gl_PointCoord.x, gl_PointCoord.y, 0, 1); R"(precision mediump float;
}); void main()
{
gl_FragColor = vec4(gl_PointCoord.x, gl_PointCoord.y, 0, 1);
})";
const std::string vs = const std::string vs =
SHADER_SOURCE(attribute vec4 vPosition; uniform float uPointSize; void main() { R"(attribute vec4 vPosition;
uniform float uPointSize;
void main()
{
gl_PointSize = uPointSize; gl_PointSize = uPointSize;
gl_Position = vPosition; gl_Position = vPosition;
}); })";
ANGLE_GL_PROGRAM(program, vs, fs); ANGLE_GL_PROGRAM(program, vs, fs);
@ -156,25 +162,19 @@ TEST_P(PointSpritesTest, PointWithoutAttributesCompliance)
return; return;
} }
// clang-format off const std::string fs =
const std::string fs = SHADER_SOURCE R"(precision mediump float;
(
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
} })";
);
const std::string vs = SHADER_SOURCE const std::string vs =
( R"(void main()
void main()
{ {
gl_PointSize = 2.0; gl_PointSize = 2.0;
gl_Position = vec4(0.0, 0.0, 0.0, 1.0); gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
} })";
);
// clang-format on
ANGLE_GL_PROGRAM(program, vs, fs); ANGLE_GL_PROGRAM(program, vs, fs);
ASSERT_GL_NO_ERROR(); ASSERT_GL_NO_ERROR();
@ -201,7 +201,10 @@ TEST_P(PointSpritesTest, PointCoordRegressionTest)
} }
const std::string fs = const std::string fs =
SHADER_SOURCE(precision mediump float; varying vec4 v_color; void main() { R"(precision mediump float;
varying vec4 v_color;
void main()
{
// It seems as long as this mathematical expression references // It seems as long as this mathematical expression references
// gl_PointCoord, the fragment's color is incorrect. // gl_PointCoord, the fragment's color is incorrect.
vec2 diff = gl_PointCoord - vec2(.5, .5); vec2 diff = gl_PointCoord - vec2(.5, .5);
@ -210,17 +213,20 @@ TEST_P(PointSpritesTest, PointCoordRegressionTest)
// The point should be a solid color. // The point should be a solid color.
gl_FragColor = v_color; gl_FragColor = v_color;
}); })";
const std::string vs = const std::string vs =
SHADER_SOURCE(varying vec4 v_color; R"(varying vec4 v_color;
// The X and Y coordinates of the center of the point. // The X and Y coordinates of the center of the point.
attribute vec2 a_vertex; uniform float u_pointSize; void main() { attribute vec2 a_vertex;
gl_PointSize = u_pointSize; uniform float u_pointSize;
gl_Position = vec4(a_vertex, 0.0, 1.0); void main()
// The color of the point. {
v_color = vec4(0.0, 1.0, 0.0, 1.0); gl_PointSize = u_pointSize;
}); gl_Position = vec4(a_vertex, 0.0, 1.0);
// The color of the point.
v_color = vec4(0.0, 1.0, 0.0, 1.0);
})";
ANGLE_GL_PROGRAM(program, vs, fs); ANGLE_GL_PROGRAM(program, vs, fs);
ASSERT_GL_NO_ERROR(); ASSERT_GL_NO_ERROR();
@ -278,18 +284,27 @@ TEST_P(PointSpritesTest, PointSizeEnabledCompliance)
return; return;
} }
const std::string fs = SHADER_SOURCE(precision mediump float; varying vec4 color; const std::string fs =
R"(precision mediump float;
varying vec4 color;
void main() { gl_FragColor = color; }); void main()
{
gl_FragColor = color;
})";
const std::string vs = SHADER_SOURCE(attribute vec3 pos; attribute vec4 colorIn; const std::string vs =
uniform float pointSize; varying vec4 color; R"(attribute vec3 pos;
attribute vec4 colorIn;
uniform float pointSize;
varying vec4 color;
void main() { void main()
gl_PointSize = pointSize; {
color = colorIn; gl_PointSize = pointSize;
gl_Position = vec4(pos, 1.0); color = colorIn;
}); gl_Position = vec4(pos, 1.0);
})";
// The WebGL test is drawn on a 2x2 canvas. Emulate this by setting a 2x2 viewport. // The WebGL test is drawn on a 2x2 canvas. Emulate this by setting a 2x2 viewport.
glViewport(0, 0, 2, 2); glViewport(0, 0, 2, 2);
@ -387,15 +402,20 @@ TEST_P(PointSpritesTest, PointSizeEnabledCompliance)
// Verify that rendering works correctly when gl_PointSize is declared in a shader but isn't used // Verify that rendering works correctly when gl_PointSize is declared in a shader but isn't used
TEST_P(PointSpritesTest, PointSizeDeclaredButUnused) TEST_P(PointSpritesTest, PointSizeDeclaredButUnused)
{ {
const std::string vs = SHADER_SOURCE(attribute highp vec4 position; const std::string vs =
R"(attribute highp vec4 position;
void main(void) { void main(void)
gl_PointSize = 1.0; {
gl_Position = position; gl_PointSize = 1.0;
}); gl_Position = position;
})";
const std::string fs = const std::string fs =
SHADER_SOURCE(void main(void) { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }); R"(void main(void)
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
ANGLE_GL_PROGRAM(program, vs, fs); ANGLE_GL_PROGRAM(program, vs, fs);
ASSERT_GL_NO_ERROR(); ASSERT_GL_NO_ERROR();
@ -413,44 +433,34 @@ TEST_P(PointSpritesTest, PointSizeDeclaredButUnused)
// spites. // spites.
TEST_P(PointSpritesTest, PointSpriteAlternatingDrawTypes) TEST_P(PointSpritesTest, PointSpriteAlternatingDrawTypes)
{ {
// clang-format off const std::string pointFS =
const std::string pointFS = SHADER_SOURCE R"(precision mediump float;
(
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
} })";
);
const std::string pointVS = SHADER_SOURCE const std::string pointVS =
( R"(void main()
void main()
{ {
gl_PointSize = 16.0; gl_PointSize = 16.0;
gl_Position = vec4(0.0, 0.0, 0.0, 1.0); gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
} })";
);
const std::string quadFS = SHADER_SOURCE const std::string quadFS =
( R"(precision mediump float;
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
const std::string quadVS = SHADER_SOURCE const std::string quadVS =
( R"(precision mediump float;
precision mediump float;
attribute vec4 pos; attribute vec4 pos;
void main() void main()
{ {
gl_Position = pos; gl_Position = pos;
} })";
);
// clang-format on
ANGLE_GL_PROGRAM(pointProgram, pointVS, pointFS); ANGLE_GL_PROGRAM(pointProgram, pointVS, pointFS);

60
src/tests/gl_tests/ProgramBinaryTest.cpp
Просмотреть файл

@ -34,22 +34,18 @@ class ProgramBinaryTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(attribute vec4 inputAttribute;
attribute vec4 inputAttribute;
void main() void main()
{ {
gl_Position = inputAttribute; gl_Position = inputAttribute;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(void main()
void main()
{ {
gl_FragColor = vec4(1,0,0,1); gl_FragColor = vec4(1,0,0,1);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)
@ -452,25 +448,23 @@ class ProgramBinaryTransformFeedbackTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( #version 300 es\n R"(#version 300 es
in vec4 inputAttribute; in vec4 inputAttribute;
out vec4 outputVarying; out vec4 outputVarying;
void main() void main()
{ {
outputVarying = inputAttribute; outputVarying = inputAttribute;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( #version 300 es\n R"(#version 300 es
precision highp float; precision highp float;
out vec4 outputColor; out vec4 outputColor;
void main() void main()
{ {
outputColor = vec4(1,0,0,1); outputColor = vec4(1,0,0,1);
} })";
);
std::vector<std::string> transformFeedbackVaryings; std::vector<std::string> transformFeedbackVaryings;
transformFeedbackVaryings.push_back("outputVarying"); transformFeedbackVaryings.push_back("outputVarying");
@ -633,50 +627,44 @@ class ProgramBinariesAcrossPlatforms : public testing::TestWithParam<PlatformsWi
GLuint createES2ProgramFromSource() GLuint createES2ProgramFromSource()
{ {
const std::string testVertexShaderSource = SHADER_SOURCE const std::string testVertexShaderSource =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string testFragmentShaderSource = SHADER_SOURCE const std::string testFragmentShaderSource =
( R"(void main(void)
void main(void)
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
return CompileProgram(testVertexShaderSource, testFragmentShaderSource); return CompileProgram(testVertexShaderSource, testFragmentShaderSource);
} }
GLuint createES3ProgramFromSource() GLuint createES3ProgramFromSource()
{ {
const std::string testVertexShaderSource = SHADER_SOURCE const std::string testVertexShaderSource =
( #version 300 es\n R"(#version 300 es
precision highp float; precision highp float;
in highp vec4 position; in highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string testFragmentShaderSource = SHADER_SOURCE const std::string testFragmentShaderSource =
( #version 300 es \n R"(#version 300 es
precision highp float; precision highp float;
out vec4 out_FragColor; out vec4 out_FragColor;
void main(void) void main(void)
{ {
out_FragColor = vec4(1.0, 0.0, 0.0, 1.0); out_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
return CompileProgram(testVertexShaderSource, testFragmentShaderSource); return CompileProgram(testVertexShaderSource, testFragmentShaderSource);
} }

64
src/tests/gl_tests/SimpleOperationTest.cpp
Просмотреть файл

@ -54,14 +54,12 @@ void SimpleOperationTest::verifyBuffer(const std::vector<uint8_t> &data, GLenum
TEST_P(SimpleOperationTest, CompileVertexShader) TEST_P(SimpleOperationTest, CompileVertexShader)
{ {
const std::string source = SHADER_SOURCE const std::string source =
( R"(attribute vec4 a_input;
attribute vec4 a_input;
void main() void main()
{ {
gl_Position = a_input; gl_Position = a_input;
} })";
);
GLuint shader = CompileShader(GL_VERTEX_SHADER, source); GLuint shader = CompileShader(GL_VERTEX_SHADER, source);
EXPECT_NE(shader, 0u); EXPECT_NE(shader, 0u);
@ -72,15 +70,13 @@ TEST_P(SimpleOperationTest, CompileVertexShader)
TEST_P(SimpleOperationTest, CompileFragmentShader) TEST_P(SimpleOperationTest, CompileFragmentShader)
{ {
const std::string source = SHADER_SOURCE const std::string source =
( R"(precision mediump float;
precision mediump float;
varying vec4 v_input; varying vec4 v_input;
void main() void main()
{ {
gl_FragColor = v_input; gl_FragColor = v_input;
} })";
);
GLuint shader = CompileShader(GL_FRAGMENT_SHADER, source); GLuint shader = CompileShader(GL_FRAGMENT_SHADER, source);
EXPECT_NE(shader, 0u); EXPECT_NE(shader, 0u);
@ -91,21 +87,17 @@ TEST_P(SimpleOperationTest, CompileFragmentShader)
TEST_P(SimpleOperationTest, LinkProgram) TEST_P(SimpleOperationTest, LinkProgram)
{ {
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(void main()
void main()
{ {
gl_Position = vec4(1.0, 1.0, 1.0, 1.0); gl_Position = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(void main()
void main()
{ {
gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
GLuint program = CompileProgram(vsSource, fsSource); GLuint program = CompileProgram(vsSource, fsSource);
EXPECT_NE(program, 0u); EXPECT_NE(program, 0u);
@ -123,23 +115,19 @@ TEST_P(SimpleOperationTest, LinkProgramWithUniforms)
return; return;
} }
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(void main()
void main()
{ {
gl_Position = vec4(1.0, 1.0, 1.0, 1.0); gl_Position = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(precision mediump float;
precision mediump float;
uniform vec4 u_input; uniform vec4 u_input;
void main() void main()
{ {
gl_FragColor = u_input; gl_FragColor = u_input;
} })";
);
GLuint program = CompileProgram(vsSource, fsSource); GLuint program = CompileProgram(vsSource, fsSource);
EXPECT_NE(program, 0u); EXPECT_NE(program, 0u);
@ -161,22 +149,18 @@ TEST_P(SimpleOperationTest, LinkProgramWithAttributes)
return; return;
} }
const std::string vsSource = SHADER_SOURCE const std::string vsSource =
( R"(attribute vec4 a_input;
attribute vec4 a_input;
void main() void main()
{ {
gl_Position = a_input; gl_Position = a_input;
} })";
);
const std::string fsSource = SHADER_SOURCE const std::string fsSource =
( R"(void main()
void main()
{ {
gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
GLuint program = CompileProgram(vsSource, fsSource); GLuint program = CompileProgram(vsSource, fsSource);
EXPECT_NE(program, 0u); EXPECT_NE(program, 0u);

16
src/tests/gl_tests/SixteenBppTextureTest.cpp
Просмотреть файл

@ -50,9 +50,8 @@ class SixteenBppTextureTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -60,20 +59,17 @@ class SixteenBppTextureTest : public ANGLETest
{ {
gl_Position = vec4(position.xy, 0.0, 1.0); gl_Position = vec4(position.xy, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string fragmentShaderSource2D = SHADER_SOURCE const std::string fragmentShaderSource2D =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D); m2DProgram = CompileProgram(vertexShaderSource, fragmentShaderSource2D);
mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex"); mTexture2DUniformLocation = glGetUniformLocation(m2DProgram, "tex");

16
src/tests/gl_tests/SwizzleTest.cpp
Просмотреть файл

@ -64,9 +64,8 @@ class SwizzleTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -74,20 +73,17 @@ class SwizzleTest : public ANGLETest
{ {
gl_Position = position; gl_Position = position;
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);

85
src/tests/gl_tests/TextureTest.cpp
Просмотреть файл

@ -49,9 +49,8 @@ class TexCoordDrawTest : public ANGLETest
virtual std::string getVertexShaderSource() virtual std::string getVertexShaderSource()
{ {
return std::string(SHADER_SOURCE return
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -59,9 +58,7 @@ class TexCoordDrawTest : public ANGLETest
{ {
gl_Position = vec4(position.xy, 0.0, 1.0); gl_Position = vec4(position.xy, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
)
);
} }
virtual std::string getFragmentShaderSource() = 0; virtual std::string getFragmentShaderSource() = 0;
@ -140,18 +137,15 @@ class Texture2DTest : public TexCoordDrawTest
std::string getFragmentShaderSource() override std::string getFragmentShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex, texcoord); gl_FragColor = texture2D(tex, texcoord);
} })";
)
);
} }
virtual const char *getTextureUniformName() { return "tex"; } virtual const char *getTextureUniformName() { return "tex"; }
@ -497,9 +491,8 @@ class Texture2DTestWithDrawScale : public Texture2DTest
std::string getVertexShaderSource() override std::string getVertexShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
varying vec2 texcoord; varying vec2 texcoord;
@ -509,9 +502,7 @@ class Texture2DTestWithDrawScale : public Texture2DTest
{ {
gl_Position = vec4(position.xy * drawScale, 0.0, 1.0); gl_Position = vec4(position.xy * drawScale, 0.0, 1.0);
texcoord = (position.xy * 0.5) + 0.5; texcoord = (position.xy * 0.5) + 0.5;
} })";
)
);
} }
void SetUp() override void SetUp() override
@ -539,9 +530,8 @@ class Sampler2DAsFunctionParameterTest : public Texture2DTest
std::string getFragmentShaderSource() override std::string getFragmentShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision highp float;
precision highp float;
uniform sampler2D tex; uniform sampler2D tex;
varying vec2 texcoord; varying vec2 texcoord;
@ -553,9 +543,7 @@ class Sampler2DAsFunctionParameterTest : public Texture2DTest
void main() void main()
{ {
gl_FragColor = computeFragColor(tex); gl_FragColor = computeFragColor(tex);
} })";
)
);
} }
void SetUp() override void SetUp() override
@ -579,9 +567,8 @@ class TextureCubeTest : public TexCoordDrawTest
std::string getFragmentShaderSource() override std::string getFragmentShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision highp float;
precision highp float;
uniform sampler2D tex2D; uniform sampler2D tex2D;
uniform samplerCube texCube; uniform samplerCube texCube;
varying vec2 texcoord; varying vec2 texcoord;
@ -590,9 +577,7 @@ class TextureCubeTest : public TexCoordDrawTest
{ {
gl_FragColor = texture2D(tex2D, texcoord); gl_FragColor = texture2D(tex2D, texcoord);
gl_FragColor += textureCube(texCube, vec3(texcoord, 0)); gl_FragColor += textureCube(texCube, vec3(texcoord, 0));
} })";
)
);
} }
void SetUp() override void SetUp() override
@ -650,18 +635,15 @@ class SamplerArrayTest : public TexCoordDrawTest
std::string getFragmentShaderSource() override std::string getFragmentShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision mediump float;
precision mediump float;
uniform highp sampler2D tex2DArray[2]; uniform highp sampler2D tex2DArray[2];
varying vec2 texcoord; varying vec2 texcoord;
void main() void main()
{ {
gl_FragColor = texture2D(tex2DArray[0], texcoord); gl_FragColor = texture2D(tex2DArray[0], texcoord);
gl_FragColor += texture2D(tex2DArray[1], texcoord); gl_FragColor += texture2D(tex2DArray[1], texcoord);
} })";
)
);
} }
void SetUp() override void SetUp() override
@ -728,9 +710,8 @@ class SamplerArrayAsFunctionParameterTest : public SamplerArrayTest
std::string getFragmentShaderSource() override std::string getFragmentShaderSource() override
{ {
return std::string(SHADER_SOURCE return
( R"(precision mediump float;
precision mediump float;
uniform highp sampler2D tex2DArray[2]; uniform highp sampler2D tex2DArray[2];
varying vec2 texcoord; varying vec2 texcoord;
@ -742,9 +723,7 @@ class SamplerArrayAsFunctionParameterTest : public SamplerArrayTest
void main() void main()
{ {
gl_FragColor = computeFragColor(tex2DArray); gl_FragColor = computeFragColor(tex2DArray);
} })";
)
);
} }
}; };
@ -3936,20 +3915,20 @@ TEST_P(TextureCubeTestES3, SpecifyAndSampleFromBaseLevel1)
} }
const std::string vs = const std::string vs =
R"(#version 300 es R"(#version 300 es
precision mediump float; precision mediump float;
in vec3 pos; in vec3 pos;
void main() { void main() {
gl_Position = vec4(pos, 1.0); gl_Position = vec4(pos, 1.0);
})"; })";
const std::string fs = const std::string fs =
R"(#version 300 es R"(#version 300 es
precision mediump float; precision mediump float;
out vec4 color; out vec4 color;
uniform samplerCube uTex; uniform samplerCube uTex;
void main(){ void main(){
color = texture(uTex, vec3(1.0)); color = texture(uTex, vec3(1.0));
})"; })";
ANGLE_GL_PROGRAM(program, vs, fs); ANGLE_GL_PROGRAM(program, vs, fs);
glUseProgram(program); glUseProgram(program);

69
src/tests/gl_tests/TransformFeedbackTest.cpp
Просмотреть файл

@ -78,14 +78,21 @@ class TransformFeedbackTest : public TransformFeedbackTestBase
ASSERT_EQ(0u, mProgram); ASSERT_EQ(0u, mProgram);
const std::string vertexShaderSource = const std::string vertexShaderSource =
SHADER_SOURCE(precision highp float; attribute vec4 position; R"(precision highp float;
attribute vec4 position;
void main() { gl_Position = position; }); void main()
{
gl_Position = position;
})";
const std::string fragmentShaderSource = const std::string fragmentShaderSource =
SHADER_SOURCE(precision highp float; R"(precision highp float;
void main() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); }); void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
mProgram = CompileProgramWithTransformFeedback(vertexShaderSource, fragmentShaderSource, mProgram = CompileProgramWithTransformFeedback(vertexShaderSource, fragmentShaderSource,
tfVaryings, bufferMode); tfVaryings, bufferMode);
@ -421,28 +428,24 @@ TEST_P(TransformFeedbackTest, MultiplePaused)
const size_t transformFeedbackCount = 8; const size_t transformFeedbackCount = 8;
// clang-format off const std::string vertexShaderSource =
const std::string vertexShaderSource = SHADER_SOURCE R"(#version 300 es
( #version 300 es\n in highp vec4 position;
in highp vec4 position; in float transformFeedbackInput;
in float transformFeedbackInput; out float transformFeedbackOutput;
out float transformFeedbackOutput; void main(void)
void main(void) {
{ gl_Position = position;
gl_Position = position; transformFeedbackOutput = transformFeedbackInput;
transformFeedbackOutput = transformFeedbackInput; })";
}
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( #version 300 es\n R"(#version 300 es
out mediump vec4 color; out mediump vec4 color;
void main(void) void main(void)
{ {
color = vec4(1.0, 1.0, 1.0, 1.0); color = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
// clang-format on
std::vector<std::string> tfVaryings; std::vector<std::string> tfVaryings;
tfVaryings.push_back("transformFeedbackOutput"); tfVaryings.push_back("transformFeedbackOutput");
@ -558,9 +561,8 @@ TEST_P(TransformFeedbackTest, MultiContext)
eglMakeCurrent(display, surface, surface, context.context); eglMakeCurrent(display, surface, surface, context.context);
// clang-format off const std::string vertexShaderSource =
const std::string vertexShaderSource = SHADER_SOURCE R"(#version 300 es
( #version 300 es\n
in highp vec4 position; in highp vec4 position;
in float transformFeedbackInput; in float transformFeedbackInput;
out float transformFeedbackOutput; out float transformFeedbackOutput;
@ -568,18 +570,15 @@ TEST_P(TransformFeedbackTest, MultiContext)
{ {
gl_Position = position; gl_Position = position;
transformFeedbackOutput = transformFeedbackInput; transformFeedbackOutput = transformFeedbackInput;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( #version 300 es\n R"(#version 300 es
out mediump vec4 color; out mediump vec4 color;
void main(void) void main(void)
{ {
color = vec4(1.0, 1.0, 1.0, 1.0); color = vec4(1.0, 1.0, 1.0, 1.0);
} })";
);
// clang-format on
std::vector<std::string> tfVaryings; std::vector<std::string> tfVaryings;
tfVaryings.push_back("transformFeedbackOutput"); tfVaryings.push_back("transformFeedbackOutput");

23
src/tests/gl_tests/UniformBufferTest.cpp
Просмотреть файл

@ -29,14 +29,23 @@ class UniformBufferTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
mVertexShaderSource = SHADER_SOURCE(#version 300 es\n in vec4 position; mVertexShaderSource =
void main() { gl_Position = position; }); R"(#version 300 es
in vec4 position;
void main()
{
gl_Position = position;
})";
mFragmentShaderSource = mFragmentShaderSource =
SHADER_SOURCE(#version 300 es\n precision highp float; uniform uni { vec4 color; }; R"(#version 300 es
precision highp float;
out vec4 fragColor; uniform uni { vec4 color; };
out vec4 fragColor;
void main() { fragColor = color; }); void main()
{
fragColor = color;
})";
mProgram = CompileProgram(mVertexShaderSource, mFragmentShaderSource); mProgram = CompileProgram(mVertexShaderSource, mFragmentShaderSource);
ASSERT_NE(mProgram, 0u); ASSERT_NE(mProgram, 0u);

16
src/tests/gl_tests/UniformTest.cpp
Просмотреть файл

@ -110,25 +110,21 @@ TEST_P(UniformTest, UniformArrayLocations)
return; return;
} }
const std::string vertexShader = SHADER_SOURCE const std::string vertexShader =
( R"(precision mediump float;
precision mediump float;
uniform float uPosition[4]; uniform float uPosition[4];
void main(void) void main(void)
{ {
gl_Position = vec4(uPosition[0], uPosition[1], uPosition[2], uPosition[3]); gl_Position = vec4(uPosition[0], uPosition[1], uPosition[2], uPosition[3]);
} })";
);
const std::string fragShader = SHADER_SOURCE const std::string fragShader =
( R"(precision mediump float;
precision mediump float;
uniform float uColor[4]; uniform float uColor[4];
void main(void) void main(void)
{ {
gl_FragColor = vec4(uColor[0], uColor[1], uColor[2], uColor[3]); gl_FragColor = vec4(uColor[0], uColor[1], uColor[2], uColor[3]);
} })";
);
GLuint program = CompileProgram(vertexShader, fragShader); GLuint program = CompileProgram(vertexShader, fragShader);
ASSERT_NE(program, 0u); ASSERT_NE(program, 0u);

16
src/tests/gl_tests/UnpackAlignmentTest.cpp
Просмотреть файл

@ -31,26 +31,22 @@ class UnpackAlignmentTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(uniform sampler2D tex;
uniform sampler2D tex;
void main() void main()
{ {
gl_FragColor = texture2D(tex, vec2(0.0, 1.0)); gl_FragColor = texture2D(tex, vec2(0.0, 1.0));
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

16
src/tests/gl_tests/UnpackRowLength.cpp
Просмотреть файл

@ -31,26 +31,22 @@ class UnpackRowLengthTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string vertexShaderSource = SHADER_SOURCE const std::string vertexShaderSource =
( R"(precision highp float;
precision highp float;
attribute vec4 position; attribute vec4 position;
void main() void main()
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string fragmentShaderSource = SHADER_SOURCE const std::string fragmentShaderSource =
( R"(uniform sampler2D tex;
uniform sampler2D tex;
void main() void main()
{ {
gl_FragColor = texture2D(tex, vec2(0.0, 1.0)); gl_FragColor = texture2D(tex, vec2(0.0, 1.0));
} })";
);
mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource); mProgram = CompileProgram(vertexShaderSource, fragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

16
src/tests/gl_tests/ViewportTest.cpp
Просмотреть файл

@ -122,23 +122,19 @@ class ViewportTest : public ANGLETest
{ {
ANGLETest::SetUp(); ANGLETest::SetUp();
const std::string testVertexShaderSource = SHADER_SOURCE const std::string testVertexShaderSource =
( R"(attribute highp vec4 position;
attribute highp vec4 position;
void main(void) void main(void)
{ {
gl_Position = position; gl_Position = position;
} })";
);
const std::string testFragmentShaderSource = SHADER_SOURCE const std::string testFragmentShaderSource =
( R"(void main(void)
void main(void)
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
mProgram = CompileProgram(testVertexShaderSource, testFragmentShaderSource); mProgram = CompileProgram(testVertexShaderSource, testFragmentShaderSource);
if (mProgram == 0) if (mProgram == 0)

23
src/tests/perf_tests/TexSubImage.cpp
Просмотреть файл

@ -131,15 +131,24 @@ void TexSubImageBenchmark::initializeBenchmark()
{ {
const auto &params = GetParam(); const auto &params = GetParam();
const std::string vs = SHADER_SOURCE(attribute vec4 a_position; attribute vec2 a_texCoord; const std::string vs =
varying vec2 v_texCoord; void main() { R"(attribute vec4 a_position;
gl_Position = a_position; attribute vec2 a_texCoord;
v_texCoord = a_texCoord; varying vec2 v_texCoord;
}); void main()
{
gl_Position = a_position;
v_texCoord = a_texCoord;
})";
const std::string fs = const std::string fs =
SHADER_SOURCE(precision mediump float; varying vec2 v_texCoord; uniform sampler2D s_texture; R"(precision mediump float;
void main() { gl_FragColor = texture2D(s_texture, v_texCoord); }); varying vec2 v_texCoord;
uniform sampler2D s_texture;
void main()
{
gl_FragColor = texture2D(s_texture, v_texCoord);
})";
mProgram = CompileProgram(vs, fs); mProgram = CompileProgram(vs, fs);
ASSERT_NE(0u, mProgram); ASSERT_NE(0u, mProgram);

30
src/tests/test_utils/draw_call_perf_utils.cpp
Просмотреть файл

@ -18,49 +18,37 @@ namespace
const char *SimpleScaleAndOffsetVertexShaderSource() const char *SimpleScaleAndOffsetVertexShaderSource()
{ {
// clang-format off return
return SHADER_SOURCE R"(attribute vec2 vPosition;
(
attribute vec2 vPosition;
uniform float uScale; uniform float uScale;
uniform float uOffset; uniform float uOffset;
void main() void main()
{ {
gl_Position = vec4(vPosition * vec2(uScale) + vec2(uOffset), 0, 1); gl_Position = vec4(vPosition * vec2(uScale) + vec2(uOffset), 0, 1);
} })";
);
// clang-format on
} }
const char *SimpleDrawVertexShaderSource() const char *SimpleDrawVertexShaderSource()
{ {
// clang-format off return
return SHADER_SOURCE R"(attribute vec2 vPosition;
(
attribute vec2 vPosition;
const float scale = 0.5; const float scale = 0.5;
const float offset = -0.5; const float offset = -0.5;
void main() void main()
{ {
gl_Position = vec4(vPosition * vec2(scale) + vec2(offset), 0, 1); gl_Position = vec4(vPosition * vec2(scale) + vec2(offset), 0, 1);
} })";
);
// clang-format on
} }
const char *SimpleFragmentShaderSource() const char *SimpleFragmentShaderSource()
{ {
// clang-format off return
return SHADER_SOURCE R"(precision mediump float;
(
precision mediump float;
void main() void main()
{ {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
} })";
);
// clang-format on
} }
void Generate2DTriangleData(size_t numTris, std::vector<float> *floatData) void Generate2DTriangleData(size_t numTris, std::vector<float> *floatData)

2
util/shader_utils.h
Просмотреть файл

@ -18,8 +18,6 @@
#include <string> #include <string>
#include <vector> #include <vector>
#define SHADER_SOURCE(...) #__VA_ARGS__
ANGLE_EXPORT GLuint CompileShader(GLenum type, const std::string &source); ANGLE_EXPORT GLuint CompileShader(GLenum type, const std::string &source);
ANGLE_EXPORT GLuint CompileShaderFromFile(GLenum type, const std::string &sourcePath); ANGLE_EXPORT GLuint CompileShaderFromFile(GLenum type, const std::string &sourcePath);