Attachment 117373 Details for Bug 91461 – Tessellation test case

Tessellation test case

tessellation.cpp (text/plain), 6.03 KB, created by Daniel Scharrer on 2015-07-25 14:34:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Daniel Scharrer

Created: 2015-07-25 14:34:24 UTC

Size: 6.03 KB

patch

obsolete

>#if 0
>
>#/*
># * Reduced test case for tessellation problem with radeonsi.
># *
># * Usage: sh tessellation.cpp
># *
># * Requirements: SDL 2, libepoxy
># */
>
>input="$0"
>output="${input%.*}"
>
>"${CXX:-g++}" "$input" -o "$output" -lSDL2 -lepoxy -std=c++11 || exit 1
>
>exec "$output"
>exit 1
>
>#endif
>
>
>#include <iostream>
>#include <iomanip>
>#include <string>
>
>#include <SDL2/SDL.h>
>#include <epoxy/gl.h>
>
>static GLAPIENTRY void debug_callback(GLenum source, GLenum type, GLuint id,
>                                      GLenum severity, GLsizei length,
>                                      const GLchar * message, const void * userParam) {
>	std::cerr << "GL debug: " << message << '\n';
>}
>
>static int init_debug() {
>	
>	glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
>	
>	glDebugMessageCallbackARB(debug_callback, 0);
>	
>	glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE);
>	
>	std::string debug_message = "GL debug output enabled";
>	glDebugMessageInsertARB(GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_OTHER_ARB,
>	                        1, GL_DEBUG_SEVERITY_LOW_ARB, debug_message.size(),
>	                        debug_message.c_str());
>}
>
>static const GLuint vertex_attrib_location = 0;
>
>static const char vertex_shader[] = R"glsl(
>#version 330
>
>in vec2 vertex_position;
>out vec2 corner_position;
>
>void main() {
>	corner_position = vertex_position * 0.8;
>}
>)glsl";
>
>static const char tessellation_control_shader[] = R"glsl(
>#version 330
>#extension GL_ARB_tessellation_shader : enable
>
>layout(vertices = 4) out;
>
>in vec2 corner_position[];
>out vec2 corner_positions[];
>patch out vec4 patch_color;
>
>uniform int invocation;
>
>void main() {
>	corner_positions[gl_InvocationID] = corner_position[gl_InvocationID];
>	if(gl_InvocationID == invocation) {
>		gl_TessLevelInner[0] = 3;
>		gl_TessLevelInner[1] = 3;
>		gl_TessLevelOuter[0] = 3;
>		gl_TessLevelOuter[1] = 3;
>		gl_TessLevelOuter[2] = 3;
>		gl_TessLevelOuter[3] = 3;
>	}
>	barrier();
>	if(gl_InvocationID == 0) {
>		patch_color = vec4(gl_TessLevelOuter[3] / 3.f, 1.f, 0.f, 1.f);
>	}
>}
>)glsl";
>
>static const char tessellation_evaluation_shader[] = R"glsl(
>#version 330
>#extension GL_ARB_tessellation_shader : enable
>
>layout(quads, fractional_odd_spacing, ccw) in;
>
>in vec2 corner_positions[];
>patch in vec4 patch_color;
>out vec4 color;
>
>void main() {
>	color = patch_color;
>	vec2 a = mix(corner_positions[0], corner_positions[1], gl_TessCoord.x);
>	vec2 b = mix(corner_positions[3], corner_positions[2], gl_TessCoord.x);
>	vec2 pos = mix(a, b, gl_TessCoord.y);
>	gl_Position = vec4(pos, 0.f, 1.f);
>}
>)glsl";
>
>static const char fragment_shader[] = R"glsl(
>#version 330
>
>in vec4 color;
>
>void main() {
>	gl_FragColor = color;
>}
>)glsl";
>
>static void compile_shader(GLuint program, GLenum type, const char * source) {
>	GLuint vertex = glCreateShader(type);
>	glShaderSource(vertex, 1, &source, 0);
>	glCompileShader(vertex);
>	glAttachShader(program, vertex);
>}
>
>static GLuint compile_program() {
>	
>	GLuint program = glCreateProgram();
>	
>	compile_shader(program, GL_VERTEX_SHADER, vertex_shader);
>	compile_shader(program, GL_TESS_CONTROL_SHADER, tessellation_control_shader);
>	compile_shader(program, GL_TESS_EVALUATION_SHADER, tessellation_evaluation_shader);
>	compile_shader(program, GL_FRAGMENT_SHADER, fragment_shader);
>	
>	glBindAttribLocation(program, vertex_attrib_location, "vertex_position");
>	
>	glLinkProgram(program);
>	
>	return program;
>}
>
>int main() {
>	
>	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
>	
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
>	
>	int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
>	int w = 800, h = 600;
>	Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
>	SDL_Window * window = SDL_CreateWindow("tessellation", x, y, w, h, flags);
>	SDL_GLContext context = SDL_GL_CreateContext(window);
>	
>	SDL_GL_SetSwapInterval(1);
>	
>	std::cout << "GL version: " << glGetString(GL_VERSION) << '\n';
>	
>	init_debug();
>	
>	glViewport(0, 0, w, h);
>	
>	GLuint program = compile_program();
>	glUseProgram(program);
>	
>	GLuint vao;
>	glCreateVertexArrays(1, &vao);
>	glBindVertexArray(vao);
>	
>	GLuint vbo;
>	glCreateBuffers(1, &vbo);
>	glBindBuffer(GL_ARRAY_BUFFER, vbo);
>	float data[][2] = {
>		{ -1.f, -1.f },
>		{ -1.f,  1.f },
>		{  1.f,  1.f },
>		{  1.f, -1.f },
>	};
>	glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
>	glVertexAttribPointer(vertex_attrib_location, 2, GL_FLOAT, GL_FALSE, 0, 0);
>	glEnableVertexAttribArray(vertex_attrib_location);
>	
>	glPatchParameteri(GL_PATCH_VERTICES, 4);
>	
>	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
>	
>	GLint invocation = 0;
>	GLint instance_location = glGetUniformLocation(program, "invocation");
>	bool invocation_changed = true;
>	
>	if(glGetError()) {
>		return 1;
>	}
>	
>	while(true) {
>		
>		SDL_Event event;
>		while(SDL_PollEvent(&event)) {
>			switch(event.type) {
>				case SDL_WINDOWEVENT: {
>					if(event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
>						w = event.window.data1, h = event.window.data2;
>						glViewport(0, 0, w, h);
>					}
>					break;
>				}
>				case SDL_KEYDOWN: {
>					switch(event.key.keysym.sym) {
>						case SDLK_DOWN:
>						case SDLK_LEFT: {
>							invocation = (invocation + 3) % 4;
>							invocation_changed = true;
>							break;
>						}
>						case SDLK_UP:
>						case SDLK_RIGHT: {
>							invocation = (invocation + 1) % 4;
>							invocation_changed = true;
>							break;
>						}
>						case SDLK_SPACE:
>						case SDLK_RETURN: {
>							invocation = (invocation == 3 ? 0 : 3);
>							invocation_changed = true;
>							break;
>						}
>						case SDLK_q:
>						case SDLK_ESCAPE: {
>							return 0;
>						}
>					}
>					break;
>				}
>				case SDL_QUIT: return 0;
>			}
>		}
>		
>		if(invocation_changed) {
>			std::cout << "if(gl_InvocationID == " << invocation << ") { â¦ }" << '\n';
>			glUniform1i(instance_location, invocation);
>			invocation_changed = false;
>		}
>		
>		glClearColor(0.f, 0.f, 0.f, 0.f);
>		glClear(GL_COLOR_BUFFER_BIT);
>		
>		glDrawArrays(GL_PATCHES, 0, 4);
>		
>		SDL_GL_SwapWindow(window);
>		
>	}
>	
>	return 1;
>}

Actions: View

Attachments on bug 91461: 117373

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.