Esempio n. 1
0
void
piglit_init(int argc, char **argv)
{
	unsigned i;

	(void) argc;
	(void) argv;

	piglit_require_vertex_program();
	piglit_require_fragment_program();
	piglit_require_extension("GL_NV_vertex_program2_option");
	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	for (i = 0; i < ARRAY_SIZE(progs); i++) {
		char shader_source[1024];

		snprintf(shader_source, sizeof(shader_source),
			 vertex_source_template);

		progs[i] = piglit_compile_program(GL_VERTEX_PROGRAM_ARB,
						  shader_source);
	}

	glEnable(GL_FRAGMENT_PROGRAM_ARB);
	glEnable(GL_VERTEX_PROGRAM_ARB);

	frag_prog = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB,
					   fragment_source);
	glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, frag_prog);

	glClearColor(clear_color[0],
		     clear_color[1],
		     clear_color[2],
		     clear_color[3]);
}
Esempio n. 2
0
void
piglit_init(int argc, char **argv)
{
	static const char components[] = "xyzw";
	unsigned i;

	(void) argc;
	(void) argv;

	piglit_require_vertex_program();
	piglit_require_fragment_program();
	piglit_require_extension("GL_NV_vertex_program2_option");
	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	for (i = 0; i < ARRAY_SIZE(progs); i++) {
		char shader_source[1024];

		snprintf(shader_source, sizeof(shader_source),
			 vertex_source_template,
			 components[i + 0],
			 components[i + 2]);

		progs[i] = piglit_compile_program(GL_VERTEX_PROGRAM_ARB,
						  shader_source);
	}

	glEnable(GL_FRAGMENT_PROGRAM_ARB);
	glEnable(GL_VERTEX_PROGRAM_ARB);
	glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, piglit_ARBfp_pass_through);

	glClearColor(0.5, 0.5, 0.5, 1.0);
}
Esempio n. 3
0
void
piglit_init(int argc, char **argv)
{
	(void) argc;
	(void) argv;

	piglit_require_vertex_program();
	piglit_require_fragment_program();
	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	progs[0] = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB,
					  cos_shader_source);
	progs[1] = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB,
					  sge_shader_source);

	vert_prog = piglit_compile_program(GL_VERTEX_PROGRAM_ARB,
					   vert_shader_source);

	glClearColor(0.5, 0.5, 0.5, 1.0);
}
Esempio n. 4
0
void piglit_init(int argc, char **argv)
{
	piglit_automatic = GL_TRUE;

	piglit_require_vertex_program();
}
Esempio n. 5
0
void
piglit_init(int argc, char **argv)
{
	unsigned r;
	unsigned c;
	unsigned i;


	(void) argc;
	(void) argv;

	piglit_require_vertex_program();
	piglit_require_fragment_program();
	piglit_require_extension("GL_NV_fragment_program_option");
	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	vert_prog = piglit_compile_program(GL_VERTEX_PROGRAM_ARB,
					   vert_shader_source);
	frag_prog = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB,
					   frag_shader_source);

	glClearColor(0.5, 0.5, 0.5, 1.0);

	i = 0;
	for (r = 0; r < TEST_ROWS; r++) {
		for (c = 0; c < TEST_COLS; c++) {
			position[i + 0] = (float)((BOX_SIZE / 2) + c *
						  (BOX_SIZE + 1) + 1);
			position[i + 1] = (float)((BOX_SIZE / 2) + r *
						  (BOX_SIZE + 1) + 1);
			position[i + 2] = 0.0f;
			position[i + 3] = 1.0f;
			i += 4;
		}
	}


	/* Generate a bunch of random direction vectors.  Based on the random
	 * direction vector, generate an axis such that the reflection of the
	 * random vector across the axis is { 0, 1, 0 }.
	 */
	srand(time(NULL));
	for (i = 0; i < (ARRAY_SIZE(direction) / 4); i++) {
		const double d[3] = {
			random_float(),
			random_float(),
			random_float()
		};
		const double inv_mag_d = 1.0 /
			sqrt((d[0] * d[0]) + (d[1] * d[1]) + (d[2] * d[2]));
		double a[3];
		double mag_a;


		direction[(i * 4) + 0] = d[0] * inv_mag_d;
		direction[(i * 4) + 1] = d[1] * inv_mag_d;
		direction[(i * 4) + 2] = d[2] * inv_mag_d;
		direction[(i * 4) + 3] = 0.0;

		a[0] = direction[(i * 4) + 0] + 0.0;
		a[1] = direction[(i * 4) + 1] + 1.0;
		a[2] = direction[(i * 4) + 2] + 0.0;
		mag_a = sqrt((a[0] * a[0]) + (a[1] * a[1]) + (a[2] * a[2]));

		axis[(i * 4) + 0] = a[0] / mag_a;
		axis[(i * 4) + 1] = a[1] / mag_a;
		axis[(i * 4) + 2] = a[2] / mag_a;
		axis[(i * 4) + 3] = 0.0;
	}
}
Esempio n. 6
0
void
piglit_init(int argc, char **argv)
{
	GLint max_parameters;
	GLint max_native_parameters;
	GLint max_local_parameters;
	GLint max_env_parameters;
	char *shader_source;
	bool pass = true;
	size_t len;
	int offset;
	unsigned i;

	(void) argc;
	(void) argv;

	piglit_require_vertex_program();

	/* First, query all of the limits.
	 */
	pass = query_and_require_limit(GL_MAX_PROGRAM_PARAMETERS_ARB,
				       & max_parameters,
				       "GL_MAX_PROGRAM_PARAMETERS_ARB",
				       96)
		&& pass;
	pass = query_and_require_limit(GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB,
				       & max_native_parameters,
				       "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB",
				       96)
		&& pass;
	pass = query_and_require_limit(GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB,
				       & max_local_parameters,
				       "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB",
				       96)
		&& pass;
	pass = query_and_require_limit(GL_MAX_PROGRAM_ENV_PARAMETERS_ARB,
				       & max_env_parameters,
				       "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB",
				       96)
		&& pass;
	if (!pass) {
		piglit_report_result(PIGLIT_FAIL);
	}

	/* Allocate a buffer big enough to hold any program that this test
	 * might generate.
	 */
	len = sizeof(template_header)
		+ sizeof(template_footer)
		+ sizeof(max_native_template_footer)
		+ (80 * max_parameters) + 1;
	shader_source = malloc(len);
	if (shader_source == NULL)
		piglit_report_result(PIGLIT_FAIL);

	/* Generate a program that uses the full parameter space using an
	 * array of constants.  Since only one parameter is statically used,
	 * this exercises GL_MAX_PROGRAM_PARAMETERS_ARB and *not*
	 * GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB.
	 */
	offset = snprintf(shader_source, len, template_header, max_parameters);
	for (i = 0; i < max_parameters; i++) {
		int comma = (i < (max_parameters - 1)) ? ',' : ' ';
		int used = snprintf(& shader_source[offset],
				    len - offset,
				    "\t\t{ %.1f, %.1f, %.1f, %.1f }%c\n",
				    (float) i,
				    (float) i + 0.2,
				    (float) i + 0.4,
				    (float) i + 0.6,
				    comma);
		offset += used;
	}

	memcpy(& shader_source[offset], template_footer,
	       sizeof(template_footer));

	(void) piglit_compile_program(GL_VERTEX_PROGRAM_ARB, shader_source);

	/* Generate a program that uses the full native parameter space using
	 * an array of constants.  The array is accessed indirectly, so the
	 * assembler cannot know which elements may be used.  As a result, it
	 * has to upload all of them.  This exercises
	 * GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB.
	 */
	offset = snprintf(shader_source, len, template_header,
			  max_native_parameters);
	for (i = 0; i < max_native_parameters; i++) {
		int comma = (i < (max_native_parameters - 1)) ? ',' : ' ';
		int used = snprintf(& shader_source[offset],
				    len - offset,
				    "\t\t{ %.1f, %.1f, %.1f, %.1f }%c\n",
				    (float) i,
				    (float) i + 0.2,
				    (float) i + 0.4,
				    (float) i + 0.6,
				    comma);
		offset += used;
	}

	memcpy(& shader_source[offset], max_native_template_footer,
	       sizeof(max_native_template_footer));

	(void) piglit_compile_program(GL_VERTEX_PROGRAM_ARB, shader_source);

	/* Generate a program that uses as much of the local parameter space
	 * as possible.  This basically tries to hit both ends of the
	 * program.local array without making assumptions about the relative
	 * amount of parameter space.  We only assume that the
	 * minimum-maximums of 96 are respected by the GL implementation.
	 */
	snprintf(shader_source, len, max_local_template,
		 "local",
		 "local", max_local_parameters - 47, max_local_parameters - 1);

	(void) piglit_compile_program(GL_VERTEX_PROGRAM_ARB, shader_source);

	/* Generate a program that uses as much of the env parameter space
	 * as possible.  This basically tries to hit both ends of the
	 * program.env array without making assumptions about the relative
	 * amount of parameter space.  We only assume that the
	 * minimum-maximums of 96 are respected by the GL implementation.
	 */
	snprintf(shader_source, len, max_local_template,
		 "env",
		 "env", max_env_parameters - 47, max_env_parameters - 1);

	(void) piglit_compile_program(GL_VERTEX_PROGRAM_ARB, shader_source);
}
Esempio n. 7
0
void
piglit_init(int argc, char **argv)
{
	GLint max_address_registers;
	unsigned i;

	(void) argc;
	(void) argv;

	piglit_require_vertex_program();
	piglit_require_fragment_program();
	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	glGetProgramivARB(GL_VERTEX_PROGRAM_ARB,
			  GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB,
			  & max_address_registers);
	if (max_address_registers == 0) {
		/* we have to have at least one address register */
		if (! piglit_automatic)
			printf("GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB == 0\n");

		piglit_report_result(PIGLIT_FAIL);
	} else 	if (max_address_registers == 1) {
		if (piglit_is_extension_supported("GL_NV_vertex_program2_option")) {
			/* this extension requires two address regs */
			if (! piglit_automatic)
				printf("GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB "
				       "== 1\n");

			piglit_report_result(PIGLIT_FAIL);
		} else {
			piglit_report_result(PIGLIT_SKIP);
		}
	}

	for (i = 0; i < ARRAY_SIZE(progs); i++) {
		char shader_source[1024];
		int offset[2];
		char direction[2];

		/* We want the constant offset in the instruction plus the
		 * value read from the attribute to be 1.
		 */
		offset[0] = 1 - (int) attrib[(2 * i) + 0];
		offset[1] = 1 - (int) attrib[(2 * i) + 1];

		if (offset[0] < 0) {
			direction[0] = '-';
			offset[0] = -offset[0];
		} else {
			direction[0] = '+';
		}

		if (offset[1] < 0) {
			direction[1] = '-';
			offset[1] = -offset[1];
		} else {
			direction[1] = '+';
		}

		snprintf(shader_source, sizeof(shader_source),
			 vertex_source_template,
			 direction[0], offset[0],
			 direction[1], offset[1]);

		progs[i] = piglit_compile_program(GL_VERTEX_PROGRAM_ARB,
						  shader_source);
	}

	glEnable(GL_FRAGMENT_PROGRAM_ARB);
	glEnable(GL_VERTEX_PROGRAM_ARB);
	glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, piglit_ARBfp_pass_through);

	glClearColor(0.5, 0.5, 0.5, 1.0);
}