示例#1
0
文件: main.c 项目: 07151129/sdl-gpu
int main(int argc, char* argv[])
{
	GPU_Target* screen;

	printRenderers();
	
	screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS);
	if(screen == NULL)
		return -1;
	
	printCurrentRenderer();
	
	{
		Uint32 startTime;
		long frameCount;
		Uint8 done;
		SDL_Event event;
		
		GPU_Image* image;
        #define MAX_SPRITES 100
        int numSprites;
        float positions[2*MAX_SPRITES];
        float colors[4*4*MAX_SPRITES];
        float expanded_colors[4*MAX_SPRITES];
        float src_rects[4*MAX_SPRITES];
        Uint32 v, f, p;
        GPU_ShaderBlock block;
        Uint8 shader_index;
        int i;
        SDL_Color color = {255, 255, 255, 255};
        SDL_Color red = {255, 0, 0, 255};
        SDL_Color green = {0, 255, 0, 255};
        SDL_Color blue = {0, 0, 255, 255};
        GPU_Rect src_rect;
        
        int mx, my;
        Uint32 mouse_state;
        
        image = GPU_LoadImage("data/happy_50x50.bmp");
        if(image == NULL)
            return -1;
        
        numSprites = 0;
        
        color_attr.format = GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, 4*sizeof(float), 0);
        color_attr.format.is_per_sprite = 0;
        color_attr.values = colors;
        
        
        block = load_shaders(&v, &f, &p);
        
        shader_index = 1;
        set_shader(p, &block);
        
        startTime = SDL_GetTicks();
        frameCount = 0;
        
        src_rect.x = 0;
        src_rect.y = 0;
        src_rect.w = image->w;
        src_rect.h = image->h;
        
        add_sprite(positions, colors, expanded_colors, src_rects, &numSprites, color, src_rect);
        
        done = 0;
        while(!done)
        {
            while(SDL_PollEvent(&event))
            {
                if(event.type == SDL_QUIT)
                    done = 1;
                else if(event.type == SDL_MOUSEBUTTONDOWN)
                {
                    if(event.button.x <= 150 && event.button.y <= 150)
                    {
                        if(event.button.button == SDL_BUTTON_LEFT)
                        {
                            float dx = event.button.x/3 - src_rect.x;
                            float dy = event.button.y/3 - src_rect.y;
                            src_rect.x = event.button.x/3;
                            src_rect.y = event.button.y/3;
                            src_rect.w -= dx;
                            src_rect.h -= dy;
                        }
                        else if(event.button.button == SDL_BUTTON_RIGHT)
                        {
                            src_rect.w = event.button.x/3 - src_rect.x;
                            src_rect.h = event.button.y/3 - src_rect.y;
                        }
                    }
                }
                else if(event.type == SDL_KEYDOWN)
                {
                    if(event.key.keysym.sym == SDLK_ESCAPE)
                        done = 1;
                    else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS)
                    {
                        if(numSprites < MAX_SPRITES)
                            add_sprite(positions, colors, expanded_colors, src_rects, &numSprites, color, src_rect);
                    }
                    else if(event.key.keysym.sym == SDLK_MINUS)
                    {
                        if(numSprites > 0)
                            numSprites--;
                    }
                    else if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        shader_index++;
                        shader_index %= 2;
                        if(shader_index == 0)
                            set_shader(0, NULL);
                        else if(shader_index == 1)
                            set_shader(p, &block);
                    }
                    else if(event.key.keysym.sym == SDLK_RETURN)
                    {
                        use_color_expansion = !use_color_expansion;
                        if(use_color_expansion)
                        {
                            GPU_LogError("Using attribute expansion.\n");
                            color_attr.format.is_per_sprite = 1;
                            color_attr.values = expanded_colors;
                        }
                        else
                        {
                            GPU_LogError("Using per-vertex attributes.\n");
                            color_attr.format.is_per_sprite = 0;
                            color_attr.values = colors;
                        }
                    }
                }
            }
            
            mouse_state = SDL_GetMouseState(&mx, &my);
            if(mouse_state & (SDL_BUTTON_LMASK | SDL_BUTTON_RMASK))
            {
                if(mx <= 150 && my <= 150)
                {
                    if(mouse_state & SDL_BUTTON_LMASK)
                    {
                        float dx = mx/3 - src_rect.x;
                        float dy = my/3 - src_rect.y;
                        src_rect.x = mx/3;
                        src_rect.y = my/3;
                        src_rect.w -= dx;
                        src_rect.h -= dy;
                    }
                    else if(mouse_state & SDL_BUTTON_RMASK)
                    {
                        src_rect.w = mx/3 - src_rect.x;
                        src_rect.h = my/3 - src_rect.y;
                    }
                }
            }
            
            GPU_SetUniformf(timeloc, SDL_GetTicks()/1000.0f);
            
            GPU_Clear(screen);
            
            if(use_color_expansion)
                GPU_SetAttributeSource(numSprites, color_attr);
            else
                GPU_SetAttributeSource(4*numSprites, color_attr);
            
            for(i = 0; i < numSprites; i++)
            {
                GPU_Rect r = {src_rects[4*i], src_rects[4*i+1], src_rects[4*i+2], src_rects[4*i+3]};
                GPU_Blit(image, &r, screen, positions[2*i], positions[2*i+1]);
            }
            //GPU_BlitBatchSeparate(image, screen, numSprites, positions, src_rects, expanded_colors, 0);
            
            set_shader(0, NULL);
            
            GPU_BlitScale(image, NULL, screen, 75, 75, 3.0f, 3.0f);
            GPU_Rectangle(screen, 3*src_rect.x, 3*src_rect.y, 3*(src_rect.x + src_rect.w), 3*(src_rect.y + src_rect.h), red);
            GPU_CircleFilled(screen, 3*src_rect.x, 3*src_rect.y, 4, blue);
            GPU_CircleFilled(screen, 3*(src_rect.x + src_rect.w), 3*(src_rect.y + src_rect.h), 4, green);
            
            if(shader_index == 1)
                set_shader(p, &block);
            
            
            GPU_Flip(screen);
            
            frameCount++;
            if(frameCount%500 == 0)
                printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
        }
        
        printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
        
        GPU_FreeImage(image);
        
        free_shaders(v, f, p);
	}
	
	GPU_Quit();
	
	return 0;
}
示例#2
0
文件: main.c 项目: shadowmint/sdl-gpu
int main(int argc, char* argv[])
{
	printRenderers();
	
	GPU_Target* screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS);
	if(screen == NULL)
		return -1;
	
	printCurrentRenderer();
	
	int numImages = 0;
	
	GPU_Image* images[argc-1];
	int i;
	for(i = 1; i < argc; i++)
	{
		images[numImages] = GPU_LoadImage(argv[i]);
		if(images[numImages] != NULL)
			numImages++;
	}
	
	Uint8* keystates = SDL_GetKeyState(NULL);
	GPU_Camera camera = GPU_GetDefaultCamera();
	
	float dt = 0.010f;
	Uint8 done = 0;
	SDL_Event event;
	while(!done)
	{
		while(SDL_PollEvent(&event))
		{
			if(event.type == SDL_QUIT)
				done = 1;
			else if(event.type == SDL_KEYDOWN)
			{
				if(event.key.keysym.sym == SDLK_ESCAPE)
					done = 1;
			}
		}
		
		if(keystates[KEY_UP])
		{
			camera.y -= 200*dt;
		}
		else if(keystates[KEY_DOWN])
		{
			camera.y += 200*dt;
		}
		if(keystates[KEY_LEFT])
		{
			camera.x -= 200*dt;
		}
		else if(keystates[KEY_RIGHT])
		{
			camera.x += 200*dt;
		}
		if(keystates[KEY_MINUS])
		{
			camera.zoom -= 1.0f*dt;
		}
		else if(keystates[KEY_EQUALS])
		{
			camera.zoom += 1.0f*dt;
		}
		
		GPU_ClearRGBA(screen, 255, 255, 255, 255);
		
		GPU_SetCamera(screen, &camera);
		
		float x = 100;
		float y = 100;
		for(i = 0; i < numImages; i++)
		{
			float x_scale = 150.0f/images[i]->w;
			float y_scale = 150.0f/images[i]->h;
			GPU_BlitScale(images[i], NULL, screen, x, y, x_scale, y_scale);
			
			x += 200;
			
			if((i+1)%4 == 0)
			{
				x = 100;
				y += 200;
			}
		}
		
		
		GPU_Flip(screen);
		SDL_Delay(10);
	}
	
	for(i = 0; i < numImages; i++)
	{
		GPU_FreeImage(images[i]);
	}
	
	GPU_Quit();
	
	return 0;
}
示例#3
0
文件: main.c 项目: 07151129/sdl-gpu
int main(int argc, char* argv[])
{
	GPU_Target* screen;

	printRenderers();
	
	screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS);
	if(screen == NULL)
		return -1;
	
	printCurrentRenderer();
	
	{
		Uint32 startTime;
		long frameCount;
		Uint8 done;
		SDL_Event event;
		const Uint8* keystates;
        GPU_Camera camera;
		float dt;
		SDL_Surface* surface;
		GPU_Image* image;
		GPU_Image* image1;
		GPU_Image* image2;
		GPU_Image* image3;
		GPU_Image* image4;
		
        image = GPU_LoadImage("data/test.bmp");
        //image = GPU_LoadImage("data/big_test.png");
        if(image == NULL)
            return -1;

        // Copying the annoying way
        image1 = GPU_CreateImage(image->w, image->h, GPU_FORMAT_RGBA);
        GPU_LoadTarget(image1);
        GPU_Blit(image, NULL, image1->target, image1->target->w/2, image1->target->h/2);
        GPU_FreeTarget(image1->target);

        // Copying the normal way
        image2 = GPU_CopyImage(image);

        // Copying from a surface dump
        surface = GPU_CopySurfaceFromImage(image);
        //GPU_SaveSurface(surface, "save_surf1.bmp", GPU_FILE_AUTO);
        image3 = GPU_CopyImageFromSurface(surface);
        SDL_FreeSurface(surface);

        // A buffer for window capture
        image4 = NULL;


        keystates = SDL_GetKeyState(NULL);
        camera = GPU_GetDefaultCamera();

        startTime = SDL_GetTicks();
        frameCount = 0;

        dt = 0.010f;
        done = 0;
        while(!done)
        {
            while(SDL_PollEvent(&event))
            {
                if(event.type == SDL_QUIT)
                    done = 1;
                else if(event.type == SDL_KEYDOWN)
                {
                    if(event.key.keysym.sym == SDLK_ESCAPE)
                        done = 1;
                    else if(event.key.keysym.sym == SDLK_SPACE)
                    {
                        // Take a window capture
                        GPU_FreeImage(image4);
                        image4 = GPU_CopyImageFromTarget(screen);
                    }
                }
            }
            
            if(keystates[KEY_UP])
            {
                camera.y -= 200*dt;
            }
            else if(keystates[KEY_DOWN])
            {
                camera.y += 200*dt;
            }
            if(keystates[KEY_LEFT])
            {
                camera.x -= 200*dt;
            }
            else if(keystates[KEY_RIGHT])
            {
                camera.x += 200*dt;
            }
            if(keystates[KEY_MINUS])
            {
                camera.zoom -= 1.0f*dt;
            }
            else if(keystates[KEY_EQUALS])
            {
                camera.zoom += 1.0f*dt;
            }
            
            
            GPU_ClearRGBA(screen, 100, 100, 100, 255);
            
            GPU_SetCamera(screen, &camera);
            
            GPU_Blit(image, NULL, screen, 128, 128);
            GPU_Blit(image1, NULL, screen, 128 + 256, 128);
            GPU_Blit(image2, NULL, screen, 128 + 512, 128);
            GPU_Blit(image3, NULL, screen, 128, 128 + 256);
            
            if(image4 != NULL)
                GPU_BlitScale(image4, NULL, screen, 3*screen->w/4, 3*screen->h/4, 0.25f, 0.25f);
            
            GPU_Flip(screen);
            
            frameCount++;
            if(frameCount%500 == 0)
                GPU_LogError("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
        }

        GPU_LogError("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));

        GPU_FreeImage(image);
        GPU_FreeImage(image1);
        GPU_FreeImage(image2);
        GPU_FreeImage(image3);
        GPU_FreeImage(image4);
	}
	
	GPU_Quit();
	
	return 0;
}