void G_Tick() {
	BufferTextInput();

	if (G_ContainsHeightMap(*((heightmap*)((object*)G_staticMeshes.first->value)->shape), G_camPos)) 
		printf("\rYes\n");

	vec3 dir = {0, 0, 0};
	float moveSpeed = G_moveSpeed * (SYS_deltaMillis / 1000.0);
	float rotSpeed = G_rotSpeed * (SYS_deltaMillis / 1000.0);
	if (IN_IsKeyPressed(IN_W))		dir[2]		-= moveSpeed;
	if (IN_IsKeyPressed(IN_A))		dir[0]		-= moveSpeed;
	if (IN_IsKeyPressed(IN_S))		dir[2]		+= moveSpeed;
	if (IN_IsKeyPressed(IN_D))		dir[0]		+= moveSpeed;
	if (IN_IsKeyPressed(IN_UP))		dir[1]		+= moveSpeed;
	if (IN_IsKeyPressed(IN_DOWN))	dir[1]		-= moveSpeed;
	if (IN_IsKeyPressed(IN_RIGHT))	G_camRot[1]	+= rotSpeed;
	if (IN_IsKeyPressed(IN_LEFT))	G_camRot[1]	-= rotSpeed;
	if (IN_IsKeyPressed(IN_PITCH_UP))	G_camRot[0]	+= rotSpeed;
	if (IN_IsKeyPressed(IN_PITCH_DOWN))	G_camRot[0]	-= rotSpeed;
	if (IN_IsKeyPressed(IN_ACTION)) {
		if (!actionHeld) {
			Shoot();
			actionHeld = true;
		}
	}else actionHeld = false;
	if (IN_IsKeyPressed(IN_TOGGLE)) {
		if (!toggleHeld) {
			ads = ads ? false : true;
			lastAdsTime = SYS_TimeMillis() / 1000.0;
			toggleHeld = true;
		}
	}else toggleHeld = false;
	if (IN_IsKeyPressed(IN_CHAT)) {
		if (!chatHeld) {
			IN_StartTextInput();
			C_console.inputActive = true;
			chatHeld = true;
		}
	}else chatHeld = false;
	
	if (IN_IsKeyPressed(IN_RELOAD)) {
		ReloadLevel();
	}
	
	if (G_camRot[0] > PITCH_LIMIT) G_camRot[0] = PITCH_LIMIT;
	else if (G_camRot[0] < -PITCH_LIMIT) G_camRot[0] = -PITCH_LIMIT;
	
	float c = cos(G_camRot[1]);
	float s = sin(G_camRot[1]);
	G_camPos[0] += -dir[2] * s + dir[0] * c;
	G_camPos[2] += dir[2] * c + dir[0] * s;
	G_camPos[1] += dir[1];
	
	mat4x4_translate(G_gunMat, G_camPos[0], G_camPos[1], G_camPos[2]);
	mat4x4_rotate_Y(G_gunMat, G_gunMat, G_camRot[1] + M_PI);
	mat4x4_rotate_X(G_gunMat, G_gunMat, -G_camRot[0]);

	double d, f;
	{
		termf terms[2] = {{2, 2}, {-1, 4}};
		d = G_Valuef((function) {0, 1, 2, terms},
							(SYS_TimeMillis() / 1000.0 - lastAdsTime) * 5);
		if (ads) d = 1 - d;
	}
	{
		termf terms[2] = {{1, 0.3}, {-1, 1}};
		f = G_Valuef((function) {0, 1, 2, terms},
							(SYS_TimeMillis() / 1000.0 - lastShootTime) * 5);
	}
	V_SetProj(fov->value * d + adsFov->value * (1 - d));
	vec3 resultant = {0, 0, 0};
	for (int i = 0; i < 3; i++) {
		resultant[i] += defGunPos[i];
		resultant[i] += hipGunPos[i] * d;
		resultant[i] += fireGunPos[i] * f;
		resultant[i] += hipFireGunPos[i] * d * f;
	}
	resultant[0] += d * 0.01 * cos(SYS_TimeMillis() / 2000.0);
	resultant[1] += d * 0.005 * cos(SYS_TimeMillis() / 1500.0);
	mat4x4_translate_in_place(G_gunMat, resultant[0], resultant[1], resultant[2]);
	
	HandleSmoke();

	if (IN_IsKeyPressed(IN_RELOAD)) V_reloadShaders = true;
}
Beispiel #2
0
int main(void)
{
  Primative *edits[] = {
    primative_create(CUBE, ADDITIVE),
    primative_create(SPHERE, ADDITIVE),
    primative_create(SPHERE, SUBTRACTIVE),
    primative_create(SPHERE, ADDITIVE)
  };

  primative_scale(edits[0], 0.4, 1.0, 1.5);
  primative_translate(edits[1], 0.2, 0, 0);
  primative_translate(edits[2], -0.3, 0, 0);
  primative_translate(edits[3], -0.5, 0, 0);
  primative_scale(edits[3], 0.5, 0.5, 0.5);
  edits[1]->blend = 0.2;

  sdf_args.edits = edits;
  sdf_args.num_edits = 4;

  vec3 origin = {0, 0, 0};
  vec3 halfDim = {1, 1, 1};
  OctTree *tree = octTree_create(origin, halfDim);

  octTree_populate(tree, distance);

  int num_verticies = octTree_count(tree);
  size_t vert_size = sizeof(Point);
  fprintf(stdout, "num verts %d\n", num_verticies);

  int vi = 0;
  Point *verticies = malloc(num_verticies * vert_size);
  octTree_get_points(tree, verticies, &vi);

  GLFWwindow* window;

  mat4x4 ident;
  mat4x4_identity(ident);

  glfwSetErrorCallback(error_callback);

  if (!glfwInit())
    exit(EXIT_FAILURE);

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

  window = glfwCreateWindow(640, 480, "speed dream", NULL, NULL);
  if (!window)
  {
    glfwTerminate();
    exit(EXIT_FAILURE);
  }

  glfwMakeContextCurrent(window);
  glfwSwapInterval(1);

  glEnable(GL_PROGRAM_POINT_SIZE);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);

  glfwSetKeyCallback(window, key_callback);

  mat4x4 proj;
  mat4x4 view;
  mat4x4 matrix;

  mat4x4_identity(view);
  mat4x4_identity(matrix);

  vec3_set(camera.pos, 0.0f, 0.0f, 0.0f);

  // Create Vertex Array Object
  GLuint vao;
  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);

  // Create a Vertex Buffer Object and copy the vertex data to it
  GLuint vbo;
  glGenBuffers(1, &vbo);

  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  glBufferData(GL_ARRAY_BUFFER, num_verticies * vert_size, verticies, GL_STATIC_DRAW);

  // Create and compile the shaders
  GLuint vertexShader = loadShader(GL_VERTEX_SHADER, DREAM_VERT);
  GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, DREAM_FRAG);

  // Link the vertex and fragment shader into a shader program
  GLuint shaderProgram = glCreateProgram();
  glAttachShader(shaderProgram, vertexShader);
  glAttachShader(shaderProgram, fragmentShader);
  glBindFragDataLocation(shaderProgram, 0, "outColor");
  glLinkProgram(shaderProgram);
  glUseProgram(shaderProgram);

  // Specify the layout of the vertex data
  GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
  glEnableVertexAttribArray(posAttrib);
  glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, 0);

  GLint normAttrib = glGetAttribLocation(shaderProgram, "normal");
  glEnableVertexAttribArray(normAttrib);
  glVertexAttribPointer(normAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, (void*)(3 * sizeof(GLfloat)));

  GLint colorAttrib = glGetAttribLocation(shaderProgram, "color");
  glEnableVertexAttribArray(colorAttrib);
  glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, vert_size, (void*)(6 * sizeof(GLfloat)));

  GLint uniModel = glGetUniformLocation(shaderProgram, "model");
  GLint uniView = glGetUniformLocation(shaderProgram, "view");
  GLint uniProj = glGetUniformLocation(shaderProgram, "proj");

  vec3 lightPos = {3.f, 0.f, 3.f};
  GLint uniLightPos = glGetUniformLocation(shaderProgram, "lightPos");
  glUniform3fv(uniLightPos, 1, (const GLfloat *)&lightPos);

  while (!glfwWindowShouldClose(window))
  {
    float ratio;
    int width, height;

    glfwGetFramebufferSize(window, &width, &height);
    ratio = width / (float) height;

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    vec4 movement = {0, 0, 0, 1};
    if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS)
      movement[0] -= 0.1;
    if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS)
      movement[0] += 0.1;
    if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
      movement[2] += 0.1;
    if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
      movement[2] -= 0.1;

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
      camera.pitch -= 0.05;
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
      camera.pitch += 0.05;
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
      camera.yaw += 0.05;
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
      camera.yaw -= 0.05;

    mat4x4 pitch_mat;
    mat4x4_identity(pitch_mat);
    mat4x4_rotate_X(pitch_mat, pitch_mat, camera.pitch);

    mat4x4 yaw_mat;
    mat4x4_identity(yaw_mat);
    mat4x4_rotate_Y(yaw_mat, yaw_mat, camera.yaw);

    mat4x4 inv_yaw_mat;
    mat4x4_invert(inv_yaw_mat, yaw_mat);

    vec4 rotated_movement;
    mat4x4_mul_vec4(rotated_movement, inv_yaw_mat, movement);
    camera.pos[0] += rotated_movement[0];
    camera.pos[1] += rotated_movement[1];
    camera.pos[2] += rotated_movement[2];

    mat4x4 translation_mat;
    mat4x4_translate(translation_mat, camera.pos[0], camera.pos[1], camera.pos[2]);

    mat4x4_mul(view, pitch_mat, yaw_mat);
    mat4x4_mul(view, view, translation_mat);
    glUniformMatrix4fv(uniView, 1, GL_FALSE, (const GLfloat *)&view);

    mat4x4_perspective(proj, 60 * M_PI / 180, ratio, 0.1f, 10.0f);
    glUniformMatrix4fv(uniProj, 1, GL_FALSE, (const GLfloat *)&proj);

    glUniformMatrix4fv(uniModel, 1, GL_FALSE, (const GLfloat *)&matrix);

    glDrawArrays(GL_POINTS, 0, num_verticies);

    glfwSwapBuffers(window);
    glfwPollEvents();
  }

  glDeleteProgram(shaderProgram);
  glDeleteShader(fragmentShader);
  glDeleteShader(vertexShader);

  glDeleteBuffers(1, &vbo);
  glDeleteVertexArrays(1, &vao);

  glfwDestroyWindow(window);

  free(verticies);

  glfwTerminate();
  exit(EXIT_SUCCESS);
}