instancing.c

 #define SOKOL_GLCORE33
// #define SOKOL_GLES3
 // #define SOKOL_GLES2

#define SOKOL_IMPL
#include "main.h"

SDL_Window *window = NULL;
SDL_GLContext gl_ctx;

int active = 1;


enum {
	WIDTH = 800,
	HEIGHT = 600,
	MAX_PARTICLES = 512*1024,
	NUM_PARTICLES_EMITTED_PER_FRAME = 10
};

/* vertex shader uniform block */
typedef struct {
	hmm_mat4 mvp;
} vs_params_t;

/* particle positions and velocity */
int cur_num_particles = 0;
hmm_vec3 pos[MAX_PARTICLES];
hmm_vec3 vel[MAX_PARTICLES];



#if __WINDOWS__

extern int __argc;
extern char **__argv;
int mainReal(int argc, char **argv);

// Based on Denis K response
// See: https://msdn.microsoft.com/library/dn727674.aspx
// This adds Windows specific entrypoint to clasic startpoint of your app:
// int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char*, int nShowCmd)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	return mainReal(__argc, __argv);
}


int mainReal(int argc, char **argv)

#else
int	main(int argc, char **argv)
#endif
{


	//ES 3 not working for me :(


	Uint8 *keys;

	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
		printf("Unable to init SDL: %s\n", SDL_GetError());
		return 1;
	}




#ifdef SOKOL_GLES2
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif

#ifdef SOKOL_GLES3
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif // MOBILE //

#ifdef SOKOL_GLCORE33
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#endif


	SDL_GL_LoadLibrary( NULL );


	printf(glGetString(GL_EXTENSIONS) );




	window = SDL_CreateWindow(
			"Sokol",
			SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED,
			WIDTH,
			HEIGHT,
			//SDL_WINDOW_OPENGL ||
			SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN
	);




	/* Create our opengl context and attach it to our window */
	gl_ctx = SDL_GL_CreateContext(window);


	printf("GL version: %s", glGetString(GL_VERSION) );

	/* This makes our buffer swap syncronized with the monitor's vertical refresh */
	SDL_GL_SetSwapInterval(-1);

	/* Clear our buffer with a red background */
	glClearColor ( 1.0, 0.0, 0.0, 1.0 );
	glClear ( GL_COLOR_BUFFER_BIT );




	/* setup sokol_gfx */
	sg_desc desc = {0};
	sg_setup(&desc);
	assert(sg_isvalid());
	assert(sg_query_feature(SG_FEATURE_INSTANCING));

	/* vertex buffer for static geometry (goes into vertex buffer bind slot 0) */
	const float r = 0.05f;
	const float vertices[] = {
			// positions            colors
			0.0f,   -r, 0.0f,       1.0f, 0.0f, 0.0f, 1.0f,
			r, 0.0f, r,          0.0f, 1.0f, 0.0f, 1.0f,
			r, 0.0f, -r,         0.0f, 0.0f, 1.0f, 1.0f,
			-r, 0.0f, -r,         1.0f, 1.0f, 0.0f, 1.0f,
			-r, 0.0f, r,          0.0f, 1.0f, 1.0f, 1.0f,
			0.0f,    r, 0.0f,       1.0f, 0.0f, 1.0f, 1.0f
	};
	sg_buffer vbuf_geom = sg_make_buffer(&(sg_buffer_desc){
		.size = sizeof(vertices),
				.content = vertices,
	});

	/* index buffer for static geometry */
	const uint16_t indices[] = {
			0, 1, 2,    0, 2, 3,    0, 3, 4,    0, 4, 1,
			5, 1, 2,    5, 2, 3,    5, 3, 4,    5, 4, 1
	};
	sg_buffer ibuf = sg_make_buffer(&(sg_buffer_desc){
		.type = SG_BUFFERTYPE_INDEXBUFFER,
				.size = sizeof(indices),
				.content = indices,
	});

	/* empty, dynamic instance-data vertex buffer (goes into vertex buffer bind slot 1) */
	sg_buffer vbuf_inst = sg_make_buffer(&(sg_buffer_desc){
		.size = MAX_PARTICLES * sizeof(hmm_vec3),
				.usage = SG_USAGE_STREAM
	});

	/* create a shader*/
#ifdef SOKOL_GLCORE33

	    sg_shader shd = sg_make_shader(&(sg_shader_desc){
	        .vs.uniform_blocks[0] = {
	            .size = sizeof(vs_params_t),
	            .uniforms = {
	                [0] = { .name="mvp", .type=SG_UNIFORMTYPE_MAT4 }
	            }
	        },
	        .vs.source =
	            "#version 330\n"
	            "uniform mat4 mvp;\n"
	            "in vec3 position;\n"
	            "in vec4 color0;\n"
	            "in vec3 instance_pos;\n"
	            "out vec4 color;\n"
	            "void main() {\n"
	            "  vec4 pos = vec4(position + instance_pos, 1.0);"
	            "  gl_Position = mvp * pos;\n"
	            "  color = color0;\n"
	            "}\n",
	        .fs.source =
	            "#version 330\n"
	            "in vec4 color;\n"
	            "out vec4 frag_color;\n"
	            "void main() {\n"
	            "  frag_color = color;\n"
	            "}\n",
	    });
#endif


#ifdef SOKOL_GLES3

	    sg_shader shd = sg_make_shader(&(sg_shader_desc){
	        .vs.uniform_blocks[0] = {
	            .size = sizeof(vs_params_t),
	            .uniforms = {
	                [0] = { .name="mvp", .type=SG_UNIFORMTYPE_MAT4 }
	            }
	        },
	        .vs.source =
	            "#version 300 es\n"
	            "uniform mat4 mvp;\n"
	            "in vec3 position;\n"
	            "in vec4 color0;\n"
	            "in vec3 instance_pos;\n"
	            "out vec4 color;\n"
	            "void main() {\n"
	            "  vec4 pos = vec4(position + instance_pos, 1.0);"
	            "  gl_Position = mvp * pos;\n"
	            "  color = color0;\n"
	            "}\n",
	        .fs.source =
	            "#version 300 es\n"
	            "in vec4 color;\n"
	            "out vec4 frag_color;\n"
	            "void main() {\n"
	            "  frag_color = color;\n"
	            "}\n",
	    });
#endif

#ifdef SOKOL_GLES2


	sg_shader shd = sg_make_shader(&(sg_shader_desc){
		.vs.uniform_blocks[0] = {
				.size = sizeof(vs_params_t),
				.uniforms = {
						[0] = { .name="mvp", .type=SG_UNIFORMTYPE_MAT4 }
				}
		},
		.vs.source =
				"uniform mat4 mvp;\n"
				"attribute vec3 position;\n"
				"attribute vec4 color0;\n"
				"attribute vec3 instance_pos;\n"
				"varying vec4 color;\n"
				"void main() {\n"
				"  vec4 pos = vec4(position + instance_pos, 1.0);"
				"  gl_Position = mvp * pos;\n"
				"  color = color0;\n"
				"}\n",
				.fs.source =
						"precision mediump float;\n"
						"varying vec4 color;\n"
						"void main() {\n"
						"  gl_FragColor = color;\n"
						"}\n"
	});
#endif


	/* pipeline state object, note the vertex layout definition */
	sg_pipeline pip = sg_make_pipeline(&(sg_pipeline_desc){
		.vertex_layouts = {
				[0] = {
						.stride = 28,
						.attrs = {
								[0] = { .name="position", .offset=0, .format=SG_VERTEXFORMAT_FLOAT3 },
								[1] = { .name="color0", .offset=12, .format=SG_VERTEXFORMAT_FLOAT4 }
						}
				},
				[1] = {
						.stride = 12,
						.step_func = SG_VERTEXSTEP_PER_INSTANCE,
						.attrs = {
								[0] = { .name="instance_pos", .offset=0, .format=SG_VERTEXFORMAT_FLOAT3 }
						}
				}
		},
				.shader = shd,
				.index_type = SG_INDEXTYPE_UINT16,
				.depth_stencil = {
						.depth_compare_func = SG_COMPAREFUNC_LESS_EQUAL,
						.depth_write_enabled = true
		},
		.rasterizer.cull_mode = SG_CULLMODE_BACK
	});

	/* setup resource bindings, note how the instance-data buffer
	       goes into vertex buffer slot 1 */
	sg_draw_state draw_state = {
			.pipeline = pip,
			.vertex_buffers = {
					[0] = vbuf_geom,
					[1] = vbuf_inst
			},
			.index_buffer = ibuf
	};

	/* default pass action (clear to grey) */
	sg_pass_action pass_action = { 0 };

	/* view-projection matrix */
	hmm_mat4 proj = HMM_Perspective(60.0f, (float)WIDTH/(float)HEIGHT, 0.01f, 50.0f);
	hmm_mat4 view = HMM_LookAt(HMM_Vec3(0.0f, 1.5f, 12.0f), HMM_Vec3(0.0f, 0.0f, 0.0f), HMM_Vec3(0.0f, 1.0f, 0.0f));
	hmm_mat4 view_proj = HMM_MultiplyMat4(proj, view);

	/* draw loop */
	vs_params_t vs_params;
	float roty = 0.0f;
	const float frame_time = 1.0f / 60.0f;






	SDL_Event sdl_event;

	int cur_width, cur_height;



	SDL_GetWindowSize(window, &cur_width, &cur_height);

	const Uint8 *keyboard_state  = SDL_GetKeyboardState(NULL);

	/* draw loop */
	while(active)
	{


		while( SDL_PollEvent( &sdl_event ) != 0 )
		{
			if( sdl_event.type == SDL_QUIT )
				active = 0;
		}

		if ( keyboard_state[SDL_SCANCODE_ESCAPE ]  ||  keyboard_state[SDL_QUIT ]  )
		{
			active = 0;
		}

		/* emit new particles */
		for (int i = 0; i < NUM_PARTICLES_EMITTED_PER_FRAME; i++) {
			if (cur_num_particles < MAX_PARTICLES) {
				pos[cur_num_particles] = HMM_Vec3(0.0, 0.0, 0.0);
				vel[cur_num_particles] = HMM_Vec3(
						((float)(rand() & 0x7FFF) / 0x7FFF) - 0.5f,
						((float)(rand() & 0x7FFF) / 0x7FFF) * 0.5f + 2.0f,
						((float)(rand() & 0x7FFF) / 0x7FFF) - 0.5f);
				cur_num_particles++;
			}
			else {
				break;
			}
		}

		/* update particle positions */
		for (int i = 0; i < cur_num_particles; i++) {
			vel[i].Y -= 1.0f * frame_time;
			pos[i].X += vel[i].X * frame_time;
			pos[i].Y += vel[i].Y * frame_time;
			pos[i].Z += vel[i].Z * frame_time;
			if (pos[i].Y < -2.0f) {
				pos[i].Y = -1.8f;
				vel[i].Y = -vel[i].Y;
				vel[i].X *= 0.8f; vel[i].Y *= 0.8f; vel[i].Z *= 0.8f;
			}
		}

		/* update instance data */
		sg_update_buffer(draw_state.vertex_buffers[1], pos, cur_num_particles*sizeof(hmm_vec3));

		/* model-view-projection matrix */
		roty += 1.0f;
		vs_params.mvp = HMM_MultiplyMat4(view_proj, HMM_Rotate(roty, HMM_Vec3(0.0f, 1.0f, 0.0f)));;

		// int cur_width, cur_height;
		// glfwGetFramebufferSize(w, &cur_width, &cur_height);
		sg_begin_default_pass(&pass_action, cur_width, cur_height);
		sg_apply_draw_state(&draw_state);
		sg_apply_uniform_block(SG_SHADERSTAGE_VS, 0, &vs_params, sizeof(vs_params));
		sg_draw(0, 24, cur_num_particles);
		sg_end_pass();
		sg_commit();
		// glfwSwapBuffers(w);
		//glfwPollEvents();






		SDL_GL_SwapWindow(window);

		// glfwSwapBuffers(w);
		// glfwPollEvents();
	}

	/* cleanup */

	//glfwTerminate();


	sg_shutdown();
	SDL_DestroyWindow(window);
	SDL_Quit();


}