コード例 #1
0
	manager::manager(shader_program_ptr shader)
	{
		// Reset errors, so we can track errors that happened here.
		glGetError();

		GLint blend_src_mode;
		GLint blend_dst_mode;
		// Save current blend mode
		glGetIntegerv(GL_BLEND_SRC, &blend_src_mode);
		glGetIntegerv(GL_BLEND_DST, &blend_dst_mode);
		blend_stack.push(blend_mode(blend_src_mode, blend_dst_mode, glIsEnabled(GL_BLEND) != 0));

		GLint atu;
		glGetIntegerv(GL_ACTIVE_TEXTURE, &atu);
		active_texture_unit.push(atu);

		if(shader == NULL || active_shader_program == shader) {
			return;
		}	

		if(active_shader_program != shader) {
			shader_stack.push(active_shader_program);
			active_shader_program = shader;
		}
		ASSERT_LOG(active_shader_program != NULL, "Active shader was NULL");
		check_gl_errors();
		active_shader_program->prepare_draw();

		GLenum err = glGetError();
		ASSERT_LOG(err == GL_NONE, "Error in shader code: " << shader->name() << " : 0x" << std::hex << err << ": " << gl_error_to_string(err));
	}
コード例 #2
0
ファイル: window.c プロジェクト: ifzz/merriment
SDL_GLContext* glcontext_create(SDL_Window* window) {
    glcontext_init();

    SDL_GLContext* gl = SDL_GL_CreateContext(window);

    SDL_GL_SetSwapInterval(0);

    check_gl_errors("GL Context creation");
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glEnable(GL_CULL_FACE);

    glClearColor(1, 1, 1, 1);

    SDL_LogInfo(
        SDL_LOG_CATEGORY_RENDER,
        "GL version: %s - GLSL version: %s\n",
        glGetString(GL_VERSION),
        glGetString(GL_SHADING_LANGUAGE_VERSION));

    return gl;
}
コード例 #3
0
ファイル: main.c プロジェクト: rafaelroquetto/starone
static void
handle_events(void)
{
	int running = 1;
	int status = MAIN_MENU;
	unsigned prev_ticks;

	while (running) {
		SDL_Event event;
		int delay;
		int response;

		prev_ticks = SDL_GetTicks();

		while (SDL_PollEvent(&event)) {
			if (status == GAMEPLAY) {
				response = handle_gameplay_events(event);

				if (response == MENU) {
					status = MAIN_MENU;
				}
			} else if (status == MAIN_MENU) {
				response = handle_mainmenu_events(event);

				if (response == QUIT) {
					running = 0;
				} else if (response == NEWGAME) {
					status = GAMEPLAY;
				}
			}
		}


		if (status == GAMEPLAY) {
			handle_gameplay_updates();
		} else if (status == MAIN_MENU) {
			handle_mainmenu_updates();
		}

		delay = 1000/FPS - (SDL_GetTicks() - prev_ticks);

		check_gl_errors();

		if (delay > 0)
			SDL_Delay(delay);
	}
}
コード例 #4
0
ファイル: game.c プロジェクト: ifzz/merriment
Game* game_create(int width, int height) {
    srand(time(NULL));

    Game* game = malloc(sizeof(*game));
    game->run = 0;

    game->window = window_create(width, height);
    game->gl = glcontext_create(game->window);
    game->timer = timer_create();

    glGenVertexArrays(1, &game->vao_id);
    glBindVertexArray(game->vao_id);
    check_gl_errors("VAO creation");

    game->scene = scene_create();

    return game;
}
コード例 #5
0
void c_RendererViewer::display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDisable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    //glClearDepth(1.0f);
    glDepthFunc(GL_LEQUAL);

    glColor3f(1.0f, 0.f, 0.f);
    //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    //glShadeModel(GL_SMOOTH);

    draw("");

    glutSwapBuffers();
    update_fps();
    check_gl_errors();

    return;
}
コード例 #6
0
ファイル: rossie.c プロジェクト: ParkaBoi/rossie
ross_internal void 
render(Input input, Input last_input, GLuint shader_program, ProgramBuffers program_buffers)
{
    ross_persist u64 vertex_count = 0;
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shader_program);

    if(input.mouse.left)
    {
        GLfloat vertex[2] = { 0.0f, 0.0f };

        GLdouble mouse_obj_x;
        GLdouble mouse_obj_y;
        GLdouble mouse_obj_z;
        GLdouble model[16];
        GLdouble proj[16];
        GLint view[4];
        glGetDoublev(GL_MODELVIEW_MATRIX, model);
        glGetDoublev(GL_PROJECTION_MATRIX, proj);
        glGetIntegerv(GL_VIEWPORT, view);

        GLdouble win_x, win_y, win_z;

        win_x = (r64)input.mouse.x;
        win_y = (r64)view[3] - (r64)input.mouse.y;
        glReadPixels(win_x, win_y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &win_z);

        gluUnProject(win_x, win_y, win_z, model, proj, view, &mouse_obj_x, &mouse_obj_y, &mouse_obj_z);

#if 0
        GLint buffer_size;
        glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &buffer_size);
        GLfloat *buffer = (GLfloat *)ross_alloc(buffer_size * sizeof(GLfloat));
        glGetBufferSubData(GL_ARRAY_BUFFER, 0, buffer_size, buffer);

        b8 repeated_data = 0;
        for(u64 i = 0; i < buffer_size; ++i)
        {
            if(buffer[i] == mouse_obj_x && buffer[i+1] == mouse_obj_y)
            {
                printf("%lu\n", i);
                repeated_data = 1; 
                break;
            }
        }
        ross_free(buffer);
        if(!repeated_data)
        {
            vertex[0] = mouse_obj_x;
            vertex[1] = mouse_obj_y;
            vertex_count++;
            glBindBuffer(GL_ARRAY_BUFFER, program_buffers.object_buffer);
            glBufferSubData(GL_ARRAY_BUFFER, vertex_count * sizeof(vertex), sizeof(vertex), vertex);
            //printf("mousex: %.02f, mousey: %.02f \n", vertices[0], vertices[1]);
        }
#endif

            vertex[0] = mouse_obj_x;
            vertex[1] = mouse_obj_y;
            glBindBuffer(GL_ARRAY_BUFFER, program_buffers.object_buffer);
            glBufferSubData(GL_ARRAY_BUFFER, vertex_count * sizeof(vertex), sizeof(vertex), vertex);
            vertex_count++;
    }
    //printf("%lu\n", vertex_count);
    
    glPointSize(10);

    GLint position_loc = glGetAttribLocation(shader_program, "vs_position");
    glEnableVertexAttribArray(position_loc);
    glVertexAttribPointer(position_loc, 2, GL_FLOAT, GL_FALSE, 0, 0);

    check_gl_errors();
    glDrawArrays(GL_POINTS, 0, vertex_count);

    glDisableVertexAttribArray(position_loc);
}
コード例 #7
0
ファイル: main.cpp プロジェクト: lightbits/akari
int main(int argc, char **argv)
{
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
	{
		APP_LOG << "Failed to initialize SDL: " << SDL_GetError() << '\n';
		return EXIT_FAILURE;
	}

	int window_width = 640;
	int window_height = 480;
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);

	SDL_Window *window = SDL_CreateWindow(
		"Sample Application",
		SDL_WINDOWPOS_CENTERED,
		SDL_WINDOWPOS_CENTERED,
		window_width, window_height,
		SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);

	if (window == NULL)
	{
		APP_LOG << "Failed to create a window: " << SDL_GetError() << '\n';
		SDL_Quit();
		return EXIT_FAILURE;
	}

	SDL_GLContext gl_context = SDL_GL_CreateContext(window);
	SDL_GL_SetSwapInterval(1); // Wait for vertical refresh

	glewExperimental = true;
	GLenum glew_error = glewInit();
	if (glew_error != GLEW_OK)
	{
		APP_LOG << "Failed to load OpenGL functions: " << glewGetErrorString(glew_error) << '\n';
		SDL_GL_DeleteContext(gl_context);
		SDL_DestroyWindow(window);
		SDL_Quit();
		return EXIT_FAILURE;
	}

	print_debug_info();

	if(!load_game(window_width, window_height))
	{
		APP_LOG << "Failed to load content" << '\n';
		SDL_GL_DeleteContext(gl_context);
		SDL_DestroyWindow(window);
		SDL_Quit();
		return EXIT_FAILURE;
	}

	init_game();
	gui::init(window_width, window_height);	

	uint vao;
	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);
	glViewport(0, 0, window_width, window_height);

	double frame_time = 1.0 / 60.0;
	bool running = true;
	while (running)
	{
		double frame_begin = get_elapsed_time();
		handle_events(running, window);
		gui::update(frame_time);
		update_game(frame_time);
		render_game(frame_time);
		SDL_GL_SwapWindow(window);
		frame_time = get_elapsed_time() - frame_begin;

		if (check_gl_errors())
			running = false;

		if (frame_time < 1.0 / 60.0)
		{
			sleep(1.0 / 60.0 - frame_time);
			frame_time = get_elapsed_time() - frame_begin;
		}
	}

	gui::dispose();
	SDL_GL_DeleteContext(gl_context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return EXIT_SUCCESS;
}
コード例 #8
0
void
wesTriangleRateBenchmark(AppState *as)
{
	int startTime, endTime;
	size_t totalTris=0, totalVerts=0;
	float elapsedTimeMS, trisPerSecond, vertsPerSecond;
	Vertex2D *baseVerts;
	Color3D *baseColors;
	Vertex3D *baseNormals;
	Vertex2D *baseTCs;
	GLuint trianglesListIndx = 0;

	int nVertsPerAxis;
	int nFrames=0;

	Vertex2D *dispatchVerts=NULL;
	Color3D *dispatchColors=NULL;
	Vertex3D *dispatchNormals=NULL;
	Vertex2D *dispatchTCs=NULL;
	GLuint   *dispatchIndices=NULL;
	int dispatchVertexCount, dispatchTriangles;

	int screenWidth = as->imgWidth;
	GLfloat r=screenWidth;
	int screenHeight = as->imgHeight;
	int testDurationMS = as->testDurationMS;
	size_t triangleLimit = as->triangleLimit;
	double triangleAreaPixels = as->triangleAreaInPixels;
	int lighting=as->enableLighting;
	int colorMaterial = as->enableColorMaterial;
	int texturingEnabled = (as->textureSize > 0) ? 1 : 0;
	int textureSize = as->textureSize;


	/* 
	 * Objective(s): 
	 * 1. Want triangles with a specified area (e.g., 8sq pixels) for the
	 * purpose of generating a graphics load with reasonably precise
	 * characteristics .
	 * 2. Want triangles to *all* remain on-screen so that triangle rate
	 * reflects the cost of rendering visible triangles/fragments.
	 *
	 * Approach:
	 * 1. build a base mesh of vertices. This set of verts is positioned
	 * so that it will remain entirely within the view frustum no matter
	 * how we rotate it (in 2D)
	 * 2. dispatch off the mesh vertices as disjoint triangles using
	 * vertex arrays. This approach is not the most efficient way to
	 * represent densely packed triangles, but has a couple of benefits:
	 * - It allows us to easily set the maximum number of triangles per
	 *   frame to be dispatched off to the renderer w/o having to resort
	 *   to tricks like inserting degenerate triangles in strips to connect
	 *   up two disjoint strips.
	 * - It allows us to glDrawArrays rather than glDrawElements. The latter
	 *   uses one level of indirection, and will be less efficient.
	 * - In the end, we care about vertex rate, not triangle rate.
	 *
	 * An early version of this code used the glDrawElements with indices.
	 * Rather than insert compile-time switches, this old code is simply
	 * cut-n-pasted and commented out at the end of this file.
	 */

	/* Make sure we are drawing to the front buffer */
	glDrawBuffer(GL_FRONT);
	glDisable(GL_DEPTH_TEST);

	/* Clear the screen */
	glClear(GL_COLOR_BUFFER_BIT);  

	if (as->outlineMode != 0)
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);       
	else
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	/* Load identities */
	glMatrixMode( GL_PROJECTION );
	glPushMatrix();
	glLoadIdentity( );

	glMatrixMode( GL_MODELVIEW );
	glPushMatrix();
	glLoadIdentity();

	/* change range from -1..1 to 0..[screenWidth, screenHeight] */
	glTranslatef(-1.0, -1.0, 0.0);
	glScalef(2.0/r, 2.0/r, 1.0F);


	if (lighting)
	{
		/* turn on OpenGL lighting stuff */
		GLfloat lightPosition[] = {(float)screenWidth*0.5F, (float)screenHeight*0.5F, 200.0F, 1.0F};
		glEnable(GL_LIGHTING);
		glEnable(GL_LIGHT0);
		glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);

		if (colorMaterial)
		{
			glEnable(GL_COLOR_MATERIAL);
			glColorMaterial(GL_FRONT, GL_DIFFUSE);
		}
		/* just use OpenGL's default light values: directional light source */
	}
	else
	{
		glDisable(GL_LIGHTING);
		glDisable(GL_COLOR_MATERIAL);
	}

	if (texturingEnabled)
	{
		buildAndDownloadTexture(textureSize);
		glEnable(GL_TEXTURE_2D);
		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	}
	else
		glDisable(GL_TEXTURE_2D);

	/* build the base quadmesh vertex array */
	buildBaseArrays(triangleAreaPixels, as->imgWidth, as->imgHeight,
			&nVertsPerAxis, 
			&baseVerts, &baseColors, &baseNormals, &baseTCs);

	/* now, repackage that information into bundles suitable for submission
to GL using the specified primitive type */
	if (as->triangleType == DISJOINT_TRIANGLES)
	{
		int triangleLimit;

		if ((as->triangleLimit*3) > as->vertexBufLimit)
			triangleLimit = as->vertexBufLimit/3;
		else
			triangleLimit = as->triangleLimit;

		buildDisjointTriangleArrays(nVertsPerAxis,
				triangleLimit,
				&dispatchTriangles,
				&dispatchVertexCount,
				baseVerts, baseColors, 
				baseNormals, baseTCs,
				&dispatchVerts,
				&dispatchColors,
				&dispatchNormals,
				&dispatchTCs);
		as->computedVertsPerArrayCall = dispatchVertexCount;
		as->computedIndicesPerArrayCall = 0;
	}
	else if (as->triangleType == TRIANGLE_STRIPS)
	{

		if ((as->triangleLimit+2) > as->vertexBufLimit)
			triangleLimit = as->vertexBufLimit-2;
		else
			triangleLimit = as->triangleLimit;


		buildTriangleStripArrays(nVertsPerAxis,
				triangleLimit,
				&dispatchTriangles,
				&dispatchVertexCount,
				baseVerts, baseColors, 
				baseNormals, baseTCs,
				&dispatchVerts,
				&dispatchColors,
				&dispatchNormals,
				&dispatchTCs);
		as->computedVertsPerArrayCall = dispatchVertexCount;
		as->computedIndicesPerArrayCall = 0;
	}
	else if (as->triangleType == INDEXED_DISJOINT_TRIANGLES)
	{
		if ((as->triangleLimit*3) > as->vertexBufLimit)
			triangleLimit = as->vertexBufLimit/3;
		else
			triangleLimit = as->triangleLimit;

		buildIndexedDisjointTriangleArrays(nVertsPerAxis,
				triangleLimit,
				&dispatchTriangles,
				&dispatchVertexCount,
				baseVerts, baseColors, 
				baseNormals, baseTCs,
				&dispatchVerts,
				&dispatchColors,
				&dispatchNormals,
				&dispatchTCs,
				&dispatchIndices);
		as->computedVertsPerArrayCall = (nVertsPerAxis+1)*(nVertsPerAxis+1);
		as->computedIndicesPerArrayCall = dispatchVertexCount;
	}
	else if (as->triangleType == INDEXED_TRIANGLE_STRIPS)
	{

		if ((as->triangleLimit+2) > as->vertexBufLimit)
			triangleLimit = as->vertexBufLimit-2;
		else
			triangleLimit = as->triangleLimit;

		buildIndexedTriangleStripArrays(nVertsPerAxis,
				triangleLimit,
				&dispatchTriangles,
				&dispatchVertexCount,
				baseVerts, baseColors, 
				baseNormals, baseTCs,
				&dispatchVerts,
				&dispatchColors,
				&dispatchNormals,
				&dispatchTCs,
				&dispatchIndices);
		as->computedVertsPerArrayCall = (nVertsPerAxis+1)*(nVertsPerAxis+1);
		as->computedIndicesPerArrayCall = dispatchVertexCount;
	}


	/* Set up the pointers */
	glVertexPointer(2, GL_FLOAT, 0, (const GLvoid *)dispatchVerts);
	glEnableClientState(GL_VERTEX_ARRAY);
	glColorPointer(3, GL_FLOAT, 0, (const GLvoid *)dispatchColors);
	glEnableClientState(GL_COLOR_ARRAY);

	if (lighting)
	{
		glNormalPointer(GL_FLOAT, 0, (const GLvoid *)dispatchNormals);
		glEnableClientState(GL_NORMAL_ARRAY);
	}

	if (texturingEnabled)
	{
		glTexCoordPointer(2, GL_FLOAT, 0, (const GLvoid *)dispatchTCs);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	}

	glFinish();                 /* make sure all setup is finished */
	startTime = endTime = glutGet(GLUT_ELAPSED_TIME);

	while ((endTime - startTime) < testDurationMS)
	{

		int buildingList=0;

		if (as->clearPerFrame != 0)
			glClear(GL_COLOR_BUFFER_BIT); /* tmp for debug */

#if SCREENSHOT_MODE
		/* screenshot mode won't work with -retained */
		/* Clear the screen */
		glClear(GL_COLOR_BUFFER_BIT); 
		glClear(GL_COLOR_BUFFER_BIT); 
		glDrawArrays(GL_TRIANGLES, 0, dispatchVertexCount);
		glDrawArrays(GL_TRIANGLES, 0, dispatchVertexCount);
		fprintf(stderr," You have screenshot mode enabled! \n");
		fflush(stderr);
		sleep(5);
		break;
#endif


		if (as->retainedModeEnabled != 0)
		{
			if (trianglesListIndx == 0) /* no list yet, build one */
			{
				trianglesListIndx = glGenLists(1);
				/*              glNewList(trianglesListIndx, GL_COMPILE_AND_EXECUTE); */
				glNewList(trianglesListIndx, GL_COMPILE);
				buildingList = 1;
			}
			else
				glCallList(trianglesListIndx);
		}

		if ((buildingList == 0) || (as->retainedModeEnabled != 0))
		{
			switch (as->triangleType)
			{
			case DISJOINT_TRIANGLES:
				glDrawArrays(GL_TRIANGLES, 0, dispatchVertexCount);
				break;
			case TRIANGLE_STRIPS:
				glDrawArrays(GL_TRIANGLE_STRIP, 0, dispatchVertexCount);
				break;
			case INDEXED_DISJOINT_TRIANGLES:
				glDrawElements(GL_TRIANGLES, dispatchVertexCount, GL_UNSIGNED_INT, dispatchIndices);
				break;
			case INDEXED_TRIANGLE_STRIPS:
				glDrawElements(GL_TRIANGLE_STRIP, dispatchVertexCount, GL_UNSIGNED_INT, dispatchIndices);
				break;
			default:
				break;
			}
		}

		glTranslatef(r/2.0, r/2.0, 0.0F);
		glRotatef(0.01F, 0.0F, 0.0F, 1.0F);
		glTranslatef(-r/2.0, -r/2.0, 0.0F);

		if (buildingList == 1)
		{
			glEndList();
			glCallList(trianglesListIndx); 

			/* cheat - reset the clock to eliminate the time required
					   for creating the display list from the frame rate computation */
			startTime = endTime = glutGet(GLUT_ELAPSED_TIME);
		}

		endTime = glutGet(GLUT_ELAPSED_TIME);

		nFrames++;
		totalTris += dispatchTriangles;
		totalVerts += as->computedVertsPerArrayCall;

	}
	/* TODO: Ask about how to get it to draw */

	glFinish();

	endTime = glutGet(GLUT_ELAPSED_TIME);

	/* Restore the gl stack */
	glMatrixMode( GL_MODELVIEW );
	glPopMatrix();

	glMatrixMode( GL_PROJECTION );
	glPopMatrix();

	/* Before printing the results, make sure we didn't have
	 ** any GL related errors. */
	check_gl_errors();

	/* the pause that refreshes -- */
#ifdef _WIN32
	Sleep(250);
#else  
	usleep(250000);
#endif  

	elapsedTimeMS = endTime - startTime;
	float elapsedTimeS = elapsedTimeMS / 1000;
	printf("Elapsed Time: %f s\n", elapsedTimeS);
	printf("Total Triangles: %d\n", (int) totalTris);
	printf("Total Verticies: %d\n", (int) totalVerts);
	printf("Frames per Second (FPS): %f\n", nFrames / elapsedTimeS);


	/*
	 * myAppState.appName,
	 * myAppState.triangleAreaInPixels,
	 * myAppState.computedMTrisPerSecond,
	 * myAppState.computedMVertexOpsPerSecond,
	 * myAppState.computedVertsPerArrayCall,
	 * myAppState.computedMFragsPerSecond,
	 * (int) myAppState.computedIndicesPerArrayCall);
	 */

	myAppState.computedMTrisPerSecond = (totalTris / 1000000.0f) / elapsedTimeS;
	myAppState.computedMVertexOpsPerSecond = (totalVerts / 1000000.0f) / elapsedTimeS;
	myAppState.computedMFragsPerSecond = myAppState.computedMTrisPerSecond * myAppState.triangleAreaInPixels;


	printf("verts/frame = %d \n", dispatchVertexCount);
	printf("nframes = %d \n", nFrames);

	free((void *)baseVerts);
	free((void *)baseColors);
	free((void *)baseNormals);
	free((void *)baseTCs);
	free((void *)dispatchVerts);
	free((void *)dispatchColors);
	free((void *)dispatchNormals);
	free((void *)dispatchTCs);

	if (dispatchIndices != NULL)
		free((void *)dispatchIndices);

	if (texturingEnabled)
		cleanupTexture();
}
コード例 #9
0
void
buildAndDownloadTexture(int textureSize)
{
	Color4DUbyte *texturePixels;
	int i, j, indx;

#if 0
	Color4DUbyte green={0x0, 0xFF, 0x0, 0xFF};
	Color4DUbyte red={0xFF, 0x00, 0x0, 0xFF};
#endif
	Color4DUbyte green={0x0, 0xFF, 0x0, 0x3F};
	Color4DUbyte red={0xFF, 0x00, 0x0, 0x3F};

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	glGenTextures(1, &textureName);
	glBindTexture(GL_TEXTURE_2D, textureName);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);


	texturePixels = (Color4DUbyte *)malloc(sizeof(Color4DUbyte)*textureSize*textureSize);

	indx = 0;
	for (j=0;j<textureSize;j++)
	{
		Color4DUbyte *even, *odd;
		if ((j&1) == 0)                 /* odd */
		{
			even = &green;
			odd = &red;
		}
		else
		{
			even = &red;
			odd = &green;
		}

		for (i=0;i<textureSize;i++)
		{
			if ((i&1) == 0)
				texturePixels[indx] = *even;
			else
				texturePixels[indx] = *odd;
			indx++;
		}
	}

	/* it would be nice to add another parameter to select the internal
texture format from the command line. */
	glTexImage2D(GL_TEXTURE_2D, 0, TEXTURE_STORAGE_MODE, textureSize, textureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid *)texturePixels);

	free((void *)texturePixels);

	glFinish();
	check_gl_errors ();

}
コード例 #10
0
    void sprite_sheet::incremental_load(const application_folder & in_application_folder)
    {
        switch(internal_status)
        {
            case sprite_sheet_status::ready:
            case sprite_sheet_status::failed:
                break;
            case sprite_sheet_status::waiting_to_load:
            {
                if(internal_loaded_file_data.status() == file_data_status::waiting_to_load)
                {
                    internal_status = sprite_sheet_status::loading;
                    internal_loaded_file_data.load(in_application_folder, internal_sheet_file_path.c_str());
                }
                break;
            }
            case sprite_sheet_status::loading:
            {
                if(internal_loaded_file_data.status() == file_data_status::loading)
                {
                }
                else if(internal_loaded_file_data.status() == file_data_status::ready)
                {
                    auto file_data = internal_loaded_file_data.data();
                    atl::input_bit_string_type bit_string(file_data.data(), file_data.data() + file_data.size());
                    
                    // Load frames:
                    glActiveTexture(GL_TEXTURE0);

                    uint32_t numSheets;
                    atl::bit_string_read_chunked_integer<uint32_t>(bit_string, numSheets, 3);
                    uint32_t totalSprites;
                    atl::bit_string_read_chunked_integer<uint32_t>(bit_string, totalSprites, 7);

                    sprites.resize(totalSprites);
                    textures.resize(numSheets);

                    for(auto & sheetId : textures)
                    {
                        // give the sheet a valid opengl texture ID
                        glGenTextures(1, &sheetId);
                        check_gl_errors();

                        uint32_t fontSheetWidthPower, fontSheetHeightPower;
                        atl::bit_string_read_ranged_integer<uint32_t>(bit_string, fontSheetWidthPower, 0, 12);
                        atl::bit_string_read_ranged_integer<uint32_t>(bit_string, fontSheetHeightPower, 0, 12);
                        uint32_t sheetWidth = 1 << fontSheetWidthPower;
                        uint32_t sheetHeight = 1 << fontSheetHeightPower;

                        atl::size2f sheetSize(sheetWidth, sheetHeight);

                        uint32_t sheetSprites;
                        atl::bit_string_read_ranged_integer<uint32_t>(bit_string, sheetSprites, 0, totalSprites);
                        while(sheetSprites-- > 0)
                        {
                            // Deserialize the frame index:
                            uint32_t spriteIndex;
                            atl::bit_string_read_ranged_integer<uint32_t>(bit_string, spriteIndex, 0, totalSprites - 1);

                            // Deserialize the texture coordinates:
                            atl::box2f l_texCoords;
                            {
                                uint32_t l_texT, l_texR, l_texB, l_texL;
                                atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texT, 0, sheetHeight);
                                atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texR, 0, sheetWidth);
                                atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texB, 0, sheetHeight);
                                atl::bit_string_read_ranged_integer<uint32_t>(bit_string, l_texL, 0, sheetWidth);

                                if(l_texR - l_texL == 1)
                                {
                                    l_texCoords.l = l_texCoords.r = (float(l_texL) + 0.5f) / float(sheetWidth);
                                }
                                else
                                {
                                    l_texCoords.l = (float(l_texL)) / float(sheetWidth);
                                    l_texCoords.r = (float(l_texR)) / float(sheetWidth);
                                }

                                if(l_texB - l_texT == 1)
                                {
                                    l_texCoords.t = l_texCoords.b = (float(l_texT) + 0.5f) / float(sheetHeight);
                                }
                                else
                                {
                                    l_texCoords.t = (float(l_texT)) / float(sheetHeight);
                                    l_texCoords.b = (float(l_texB)) / float(sheetHeight);
                                }
                            }

                            // Deserialize the drawn area:
                            atl::box2f l_area;
                            atl::bit_string_read_values(bit_string, l_area.t, l_area.r, l_area.b, l_area.l);

                            sprites[spriteIndex].set(sheetId, l_texCoords, l_area);
                        }

                        // Decode PNG data and upload to card:
                        glBindTexture(GL_TEXTURE_2D, sheetId);

                        int32_t numPNGBytesInt32;
                        atl::bit_string_read_value(bit_string, numPNGBytesInt32);
                        size_t numPNGBytes = numPNGBytesInt32;
                        atl::bit_string_skip_to_next_byte(bit_string);
                        const unsigned char * l_pngBytes = bit_string.ptr;
                        bit_string.ptr += numPNGBytes;

                        unsigned char * imageDataOut = nullptr;
                        unsigned int imageWidthOut;
                        unsigned int imageHeightOut;
                        unsigned int decodeError = lodepng_decode32(&imageDataOut, &imageWidthOut, &imageHeightOut, l_pngBytes, numPNGBytes);
                        atl_fatal_if(decodeError > 0, "Couldn't decode PNG in sprite sheet");
                        atl_fatal_if(imageWidthOut != sheetWidth || imageHeightOut != sheetHeight, "PNG in sprite sheet of unexpected size");

                        // Allocate GL resource:
                        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
                        check_gl_errors();
                        glTexImage2D(GL_TEXTURE_2D,
                                        0,
                                        GL_RGBA,
                                        atl::integer_cast<GLsizei>(sheetWidth, [](){}),
                                        atl::integer_cast<GLsizei>(sheetHeight, [](){}),
                                        0,
                                        GL_RGBA,
                                        GL_UNSIGNED_BYTE,
                                        imageDataOut);
                        check_gl_errors();
                        GLint lFilteringMode = internal_texture_filtering_mode == texture_filtering_mode::linear ? GL_LINEAR : GL_NEAREST;
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, lFilteringMode);
                        check_gl_errors();
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, lFilteringMode);
                        check_gl_errors();

                        delete[] imageDataOut;
                    }
                    internal_loaded_file_data.free();
                    internal_status = sprite_sheet_status::ready;
                }
                else
                {
                    internal_status = sprite_sheet_status::failed;
                }
                break;
            }
        }
    }
コード例 #11
0
ファイル: init.c プロジェクト: BackupTheBerlios/bmc
void init_stuff()
{
	int seed;

	Uint32 (*my_timer_pointer) (unsigned int) = my_timer;

	//TODO: process command line options
	chdir(datadir);

	//Initialize all strings
	init_translatables();

#ifdef WRITE_XML
	load_translatables();//Write to the current working directory - hopefully we'll have write rights here...
#endif

	//read the config file
	read_config();

	//Parse command line options
	read_command_line();

	//OK, we have the video mode settings...
	setup_video_mode(full_screen,video_mode);
	//now you may set the video mode using the %<foo> in-game
	video_mode_set=1;

	//Good, we should be in the right working directory - load all translatables from their files
	load_translatables();

	init_video();
	resize_window();
	init_gl_extensions();
#ifdef CAL3D
	create_cal3d_model();
	init_cal3d_model();
#endif
	seed = time (NULL);
	srand (seed);

	cache_system_init(MAX_CACHE_SYSTEM);
	init_texture_cache();
	init_md2_cache();
	init_e3d_cache();
	init_2d_obj_cache();
	load_ignores();
	load_filters();
	load_e3d_list();
	load_e2d_list();
	load_part_list();
	load_knowledge_list();
	load_cursors();
	build_cursors();
	change_cursor(CURSOR_ARROW);
	build_glow_color_table();


	init_actors_lists();
	memset(tile_list, 0, sizeof(tile_list));
	memset(lights_list, 0, sizeof(lights_list));
	init_particles_list();
	memset(actors_defs, 0, sizeof(actors_defs));
	init_actor_defs();

	load_map_tiles();

	//lights setup
	build_global_light_table();
	build_sun_pos_table();
	reset_material();
	init_lights();
	disable_local_lights();
	init_colors();
	clear_error_log();
	clear_conn_log();
	clear_thunders();
	build_rain_table();
	read_bin_cfg();
	build_levels_table();//for some HUD stuff
	init_scale_array();

	if(!no_sound)init_sound();

	//initialize the fonts
	init_fonts();
	check_gl_errors();

	//load the necesary textures
	//font_text=load_texture_cache("./textures/font.bmp",0);
	icons_text=load_texture_cache("./textures/gamebuttons.bmp",0);
	hud_text=load_texture_cache("./textures/gamebuttons2.bmp",0);
	cons_text=load_texture_cache("./textures/console.bmp",255);
	sky_text_1=load_texture_cache("./textures/sky.bmp",70);
	particle_textures[0]=load_texture_cache("./textures/particle0.bmp",0);
	particle_textures[1]=load_texture_cache("./textures/particle1.bmp",0);
	particle_textures[2]=load_texture_cache("./textures/particle2.bmp",0);
	particle_textures[3]=load_texture_cache("./textures/particle3.bmp",0);
	particle_textures[4]=load_texture_cache("./textures/particle4.bmp",0);
	particle_textures[5]=load_texture_cache("./textures/particle5.bmp",0);
	particle_textures[6]=load_texture_cache("./textures/particle6.bmp",0);
	particle_textures[7]=load_texture_cache("./textures/particle7.bmp",0);

	items_text_1=load_texture_cache("./textures/items1.bmp",0);
	items_text_2=load_texture_cache("./textures/items2.bmp",0);
	items_text_3=load_texture_cache("./textures/items3.bmp",0);
	items_text_4=load_texture_cache("./textures/items4.bmp",0);
	items_text_5=load_texture_cache("./textures/items5.bmp",0);
	items_text_6=load_texture_cache("./textures/items6.bmp",0);
	items_text_7=load_texture_cache("./textures/items7.bmp",0);
	items_text_8=load_texture_cache("./textures/items8.bmp",0);
	items_text_9=load_texture_cache("./textures/items9.bmp",0);

	portraits1_tex=load_texture_cache("./textures/portraits1.bmp",0);
	portraits2_tex=load_texture_cache("./textures/portraits2.bmp",0);
	portraits3_tex=load_texture_cache("./textures/portraits3.bmp",0);
	portraits4_tex=load_texture_cache("./textures/portraits4.bmp",0);
	portraits5_tex=load_texture_cache("./textures/portraits5.bmp",0);
	halo_tex=load_texture_cache("./textures/halo.bmp",0);

	if(have_multitexture)ground_detail_text=load_texture_cache("./textures/ground_detail.bmp",255);
	check_gl_errors();
	create_char_error_str[0]=0;
	init_opening_interface();
	init_hud_interface();

	if(SDLNet_Init()<0)
 		{
			char str[120];
			sprintf(str,"%s: %s\n",failed_sdl_net_init,SDLNet_GetError());
			log_error(str);
			SDLNet_Quit();
			SDL_Quit();
			exit(2);
		}

	if(SDL_InitSubSystem(SDL_INIT_TIMER)<0)
		{
 			char str[120];
			sprintf(str, "%s: %s\n", failed_sdl_timer_init,SDL_GetError());
			log_error(str);
			SDL_Quit();
		 	exit(1);
		}
	SDL_SetTimer (1000/(18*4), my_timer_pointer);

	ReadXML("languages/en/Encyclopedia/index.xml");
	read_key_config();
	load_questlog();
	init_buddy();

	//initiate function pointers
	init_attribf();

	//we might want to do this later.
	connect_to_server();
}
コード例 #12
0
    void simple_font_renderer::incremental_load(const application_folder & in_application_folder)
    {
        switch(internal_status)
        {
            case simple_font_renderer_status::ready:
            case simple_font_renderer_status::failed:
                break;
            case simple_font_renderer_status::waiting_to_load:
            {
                internal_vertex_shader_file.load(in_application_folder, "SimpleFont.vsh");
                internal_fragment_shader_file.load(in_application_folder, "SimpleFont.fsh");
                internal_status = simple_font_renderer_status::loading;
                break;
            }
            case simple_font_renderer_status::loading:
            {
                auto l_vsh_status = internal_vertex_shader_file.status();
                auto l_fsh_status = internal_fragment_shader_file.status();
                if((l_vsh_status != file_data_status::loading &&
                    l_vsh_status != file_data_status::ready) ||
                    (l_fsh_status != file_data_status::loading &&
                     l_fsh_status != file_data_status::ready))
                {
                    internal_status = simple_font_renderer_status::failed;
                }
                else if(l_vsh_status == file_data_status::ready &&
                        l_fsh_status == file_data_status::ready)
                {
                    GLuint l_vertex_shader = 0, l_fragment_shader = 0;

                    if(!compile_shader(internal_vertex_shader_file.data(), &l_vertex_shader, GL_VERTEX_SHADER) ||
                       !compile_shader(internal_fragment_shader_file.data(), &l_fragment_shader, GL_FRAGMENT_SHADER))
                    {
                        atl_debug_log("Shader failed to compile");
                        internal_status = simple_font_renderer_status::failed;
                    }
                    else
                    {
                        // Index data:
                        {
                            unsigned short l_vertIdx = 0;
                            for(unsigned int idx = 0; idx < pcsm_maxIndicesPerPass; idx += pcsm_indicesPerCharacter)
                            {
                                pm_indexData[idx + 0] = l_vertIdx + 0;
                                pm_indexData[idx + 1] = l_vertIdx + 1;
                                pm_indexData[idx + 2] = l_vertIdx + 2;
                                pm_indexData[idx + 3] = l_vertIdx + 1;
                                pm_indexData[idx + 4] = l_vertIdx + 2;
                                pm_indexData[idx + 5] = l_vertIdx + 3;
                                l_vertIdx += 4;
                            }
                        }

                        // Do GL stuff to set up the vertex buffer:    
                        for(int i = 0; i < pcsm_numBuffers; i++)
                        {
                            pm_glVertexArray[i].alloc();
                            pm_glVertexBuffer[i].alloc();
                        }
                        pm_glIndexBuffer.alloc();

                        for(int idx_buffer = 0; idx_buffer < pcsm_numBuffers; idx_buffer++)
                        {
                            pm_glVertexArray[idx_buffer].bind();
                            internal_configure_vertex_array(idx_buffer);
                            glBufferData(GL_ARRAY_BUFFER, atl::c_array_byte_length(pm_vertexData), NULL, GL_DYNAMIC_DRAW);
                            check_gl_errors();
                            glBufferData(GL_ELEMENT_ARRAY_BUFFER, atl::c_array_byte_length(pm_indexData), &pm_indexData[0], GL_STATIC_DRAW);
                            check_gl_errors();
                        }
                        atl::c_array_last_by_ref(pm_glVertexArray).unbind();

                        // Create shader program.
                        pm_glProgram.alloc();

                        // Attach vertex shader to program.
                        glAttachShader(pm_glProgram, l_vertex_shader);

                        // Attach fragment shader to program.
                        glAttachShader(pm_glProgram, l_fragment_shader);

                        // Bind attribute locations.
                        // This needs to be done prior to linking.
                        glBindAttribLocation(pm_glProgram, ATTRIBUTE_VERT_POSITION, "v_position");
                        glBindAttribLocation(pm_glProgram, ATTRIBUTE_VERT_TEX_COORD, "v_texCoord");
                        glBindAttribLocation(pm_glProgram, ATTRIBUTE_VERT_COLOR, "v_color");
                        glBindAttribLocation(pm_glProgram, ATTRIBUTE_VERT_EDGE, "v_edge");
                        glBindAttribLocation(pm_glProgram, ATTRIBUTE_VERT_RADIUS, "v_radius");

                        // Link program.
                        if(link_program(pm_glProgram))
                        {
                            // Get uniform locations.
                            pm_shaderUniforms[UNIFORM_SCREEN_DIM] = glGetUniformLocation(pm_glProgram, "u_screenBounds");
                            pm_shaderUniforms[UNIFORM_TRANSLATION] = glGetUniformLocation(pm_glProgram, "u_translation");

                            pm_shaderUniforms[UNIFORM_SAMPLER_DISTANCE_FIELD] = glGetUniformLocation(pm_glProgram, "s_distanceField");

                            internal_status = simple_font_renderer_status::ready;
                        }
                        else
                        {
                            atl_debug_log("Shader failed to link");
                            pm_glProgram.free();
                            internal_status = simple_font_renderer_status::failed;
                        }
                    }

                    internal_vertex_shader_file.free();
                    internal_fragment_shader_file.free();

                    // Release vertex and fragment shaders.
                    if(l_vertex_shader != 0)
                    {
                        glDetachShader(pm_glProgram, l_vertex_shader);
                        glDeleteShader(l_vertex_shader);
                    }
                    if(l_fragment_shader != 0)
                    {
                        glDetachShader(pm_glProgram, l_fragment_shader);
                        glDeleteShader(l_fragment_shader);
                    }
                }
                break;
            }
        }
    }
コード例 #13
0
ファイル: program.c プロジェクト: nsmoooose/cardy_gl
void rendering_scene() {
	glMatrixMode(GL_MODELVIEW);
	render_scene_context(g_rcontext);
	check_gl_errors("render_scene");
	glutSwapBuffers();
}
コード例 #14
0
    void flat_textured_renderer::incremental_load(const application_folder & in_application_folder)
    {
        switch(internal_status)
        {
            case flat_textured_renderer_status::ready:
            case flat_textured_renderer_status::failed:
                break;
            case flat_textured_renderer_status::waiting_to_load:
            {
                internal_vertex_shader_file.load(in_application_folder, "flat_textured.vsh");
                internal_fragment_shader_file.load(in_application_folder, "flat_textured.fsh");
                internal_status = flat_textured_renderer_status::loading;
                break;
            }
            case flat_textured_renderer_status::loading:
            {
                auto l_vsh_status = internal_vertex_shader_file.status();
                auto l_fsh_status = internal_fragment_shader_file.status();
                if((l_vsh_status != file_data_status::loading &&
                    l_vsh_status != file_data_status::ready) ||
                   (l_fsh_status != file_data_status::loading &&
                    l_fsh_status != file_data_status::ready))
                {
                    internal_status = flat_textured_renderer_status::failed;
                }
                else if(l_vsh_status == file_data_status::ready &&
                        l_fsh_status == file_data_status::ready)
                {
                    GLuint l_vertex_shader = 0, l_fragment_shader = 0;
                    
                    if(!compile_shader(internal_vertex_shader_file.data(), &l_vertex_shader, GL_VERTEX_SHADER) ||
                       !compile_shader(internal_fragment_shader_file.data(), &l_fragment_shader, GL_FRAGMENT_SHADER))
                    {
                        atl_debug_log("Shader failed to compile");
                        internal_status = flat_textured_renderer_status::failed;
                    }
                    else
                    {
                        // Create shader program.
                        internal_program.alloc();
                        
                        // Attach vertex shader to program.
                        glAttachShader(internal_program, l_vertex_shader);
                        
                        // Attach fragment shader to program.
                        glAttachShader(internal_program, l_fragment_shader);
                        
                        // Bind attribute locations.
                        // This needs to be done prior to linking.
                        glBindAttribLocation(internal_program, ATTRIBUTE_POSITION, "v_position");
                        check_gl_errors();
                        glBindAttribLocation(internal_program, ATTRIBUTE_TEXTURE_COORDINATES, "v_texture_coordinates");
                        check_gl_errors();
                        glBindAttribLocation(internal_program, ATTRIBUTE_COLOR_MULTIPLY, "v_color_multiply");
                        check_gl_errors();
                        glBindAttribLocation(internal_program, ATTRIBUTE_COLOR_LERP, "v_color_lerp");
                        check_gl_errors();

                        // Link program.
                        if(link_program(internal_program))
                        {
                            // Get uniform locations.
                            internal_shader_uniforms[UNIFORM_SCREEN_DIM] = glGetUniformLocation(internal_program, "u_stage_bounds");
                            check_gl_errors();
                            
                            internal_status = flat_textured_renderer_status::ready;
                        }
                        else
                        {
                            atl_debug_log("Shader failed to link");
                            internal_program.free();
                            internal_status = flat_textured_renderer_status::failed;
                        }
                    }
                    
                    internal_vertex_shader_file.free();
                    internal_fragment_shader_file.free();
                    
                    // Release vertex and fragment shaders.
                    if(l_vertex_shader != 0)
                    {
                        glDetachShader(internal_program, l_vertex_shader);
                        glDeleteShader(l_vertex_shader);
                    }
                    if(l_fragment_shader != 0)
                    {
                        glDetachShader(internal_program, l_fragment_shader);
                        glDeleteShader(l_fragment_shader);
                    }
                }
                break;
            }
        }
    }
コード例 #15
0
ファイル: viewer.c プロジェクト: BIANZiyang/3PRE
static void
render_scene (Viewer *self)
{
//    glClearColor (0.0, 0.0, 0.0, 1.0);
    glClearColor(self->backgroundColor[0], self->backgroundColor[1], 
                 self->backgroundColor[2], self->backgroundColor[3]);
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    if (self->view_handler)
        self->view_handler->update_gl_matrices(self, self->view_handler);

    glMatrixMode (GL_MODELVIEW);

    /* give the ambient light a blue tint to match the blue sky */
    float light0_amb[] = { 0.8, 0.8, 1.0, 1 };
    float light0_dif[] = { 1, 1, 1, 1 };
    float light0_spe[] = { .5, .5, .5, 1 };
    float light0_pos[] = { 100, 100, 100, 0 };
    glLightfv (GL_LIGHT0, GL_AMBIENT, light0_amb);
    glLightfv (GL_LIGHT0, GL_DIFFUSE, light0_dif);
    glLightfv (GL_LIGHT0, GL_SPECULAR, light0_spe);
    glLightfv (GL_LIGHT0, GL_POSITION, light0_pos);
    glEnable (GL_LIGHT0);

    if (self->prettier_flag) {
        glEnable(GL_LINE_STIPPLE);
        glEnable(GL_LINE_SMOOTH);
        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
        glEnable(GL_POINT_SMOOTH);
        glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
    }

    for (unsigned int ridx = 0; ridx < g_ptr_array_size(self->renderers); ridx++) {
        Renderer *renderer = g_ptr_array_index(self->renderers, ridx);

        if (renderer->enabled) {
            
            glPushAttrib(GL_ENABLE_BIT | GL_POINT_BIT | GL_POLYGON_STIPPLE_BIT | 
                         GL_POLYGON_BIT | GL_LINE_BIT | GL_FOG_BIT | GL_LIGHTING_BIT );
            glPushMatrix();

            if (renderer->draw)
                renderer->draw (self, renderer);

            check_gl_errors (renderer->name);

            glPopMatrix();
            glPopAttrib();
        }
    }

/*
    glColor3f(1, 1, 1);
    glBegin(GL_POINTS);
    glVertex3f(0,0,0);
    glVertex3f(1,0,0);
    glVertex3f(2,0,0);
    glVertex3f(0,1,0);
    glEnd();
*/
}