ToyEngine/Demo/DemoWorld.cpp

#include "DemoWorld.h"
#include <Particle.h>
#include <RenderingSystem.h>

DemoWorld::DemoWorld()
{
	light.lightDirection = glm::normalize(glm::vec3((cos(lightPitch) * cos(lightYaw)), (sin(lightPitch)), (cos(lightPitch) * sin(lightYaw))));
	light.radiance = 15.f * lightColor;

	std::string modelFilePath;
	modelFilePath = "Models/vampire/vampire.gltf";

	auto actor = std::make_shared<Actor>(modelFilePath);
	actor->setRotaion(glm::angleAxis(glm::radians(-90.f), glm::vec3(1, 0, 0)));
	auto actor2 = std::make_shared<Actor>(modelFilePath);
	actor2->setRotaion(glm::angleAxis(glm::radians(-90.f), glm::vec3(1, 0, 0)));
	actor2->setPosition({ 1,0,-1 });
	auto actor3 = std::make_shared<Actor>(modelFilePath);
	actor3->setRotaion(glm::angleAxis(glm::radians(-90.f), glm::vec3(1, 0, 0)));
	actor3->setPosition({ -1,0,-1 });
	auto sponza = std::make_shared<Actor>("Models\\Sponza\\Sponza.gltf");
	sponza->setScale(glm::vec3(2));
	auto shoot = std::make_shared<Actor>("Models\\shoot_gun\\scene.gltf");
	shoot->setPosition({ 0.25,6.8,7.8 });
	shoot->setRotaion(glm::angleAxis(glm::radians(90.f), glm::vec3(0, 1, 0)));
	shoot->setScale(glm::vec3(45));

	throwPerson = std::make_shared<Actor>("Models\\grenade_throw\\grenade_throw.gltf");
	throwPerson->setPosition({ 0.25,6.8,-8.1 });
	//throwPerson->setRotaion(glm::angleAxis(glm::radians(90.f), glm::vec3(0, 1, 0)));
	throwPerson->setScale(glm::vec3{ 45 });

	mk2 = std::make_shared<Particle>(10, "Models\\mk2-frag-grenade\\mk2-frag-grenade.gltf");
	mk2->setScale(glm::vec3(0.1));
	mk2->setPosition({ 0,-100,0 });

	addActor(actor);
	addActor(actor2);
	addActor(actor3);
	addActor(sponza);
	addActor(shoot);
	addActor(throwPerson);
	addActor(mk2);

	float boardMass = 10;
	glm::vec3 boardScale(0.01);
	auto boardFilePath = "Models\\pallet_wood\\pallet_wood.gltf";


	int particleCount = 5;
	for (int i = 0; i < particleCount; i++)
	{
		auto particle = std::make_shared<Particle>(boardMass, boardFilePath);
		particle->setPosition({ 0, 8, glm::mix(-3.1f,2.f,(double)i / (particleCount - 1)) });
		particle->setScale(boardScale);
		if (i == 0 || i == particleCount - 1)
		{
			particle->setFixed(true);
		}
		else
		{
			particle->setEnableGravity(true);
		}
		particles.push_back(particle);
		addActor(particle);

		if (i != 0)
		{
			float ks = 300, kd = 100;
			physicsManager.addSpring(particles[i - 1], particle, 0.005, ks, kd);
		}
	}
}

void DemoWorld::logicalTick(float deltaTime)
{
	World::logicalTick(deltaTime);
	for (int i = 0; i < particles.size(); i++)
	{
		glm::vec3 d;
		if (i == 0)
			d = glm::normalize(particles[i + 1]->getPosition() - particles[i]->getPosition());
		else if (i == particles.size() - 1)
			d = glm::normalize(particles[i]->getPosition() - particles[i - 1]->getPosition());
		else
		{
			auto dL = particles[i + 1]->getPosition() - particles[i]->getPosition();
			auto dR = particles[i]->getPosition() - particles[i - 1]->getPosition();
			d = (glm::normalize(dL) + glm::normalize(dR)) / 2.f;
		}
		particles[i]->setRotaion(glm::rotation(glm::vec3(0, 0, 1), d));
	}

	if (abs(throwPerson->getAnimatorCurrentTime() - 3.41f) < 1e-2f)
	{
		mk2->setPosition(throwPerson->getPosition() + glm::vec3(-0.5, 2.2, 0));
		mk2->setSpeed(glm::mat3_cast(throwPerson->getRotation() * glm::rotation(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(0, 0.8, 1)/*方向*/))) * glm::vec3(8.3/*速度*/, 0, 0));
		//mk2->setSpeed(glm::mat3_cast(throwPerson->getRotation() * glm::rotation(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(0, 2, 1)/*方向*/))) * glm::vec3(10/*速度*/, 0, 0));
		mk2->setEnableGravity(true);
	}

	if (mk2->getPosition().y < 7.5f && mk2->getSpeed().y < 0)
	{
		particles[3]->setSpeed(particles[3]->getSpeed() + mk2->getSpeed() / 2.f);
		mk2->setEnableGravity(false);
		mk2->setSpeed(glm::vec3(0));
		mk2->setPosition({ 0,-100,0 });
	}

}

void DemoWorld::rendererTick(float deltaTime)
{
	World::rendererTick(deltaTime);
}

void DemoWorld::cursorPosCallback(GLFWwindow* window, double xpos, double ypos)
{
	static bool firstMouse = true;
	static float lastX;
	static float lastY;

	float xoffset = xpos - lastX;
	float yoffset = lastY - ypos;

	lastX = xpos;
	lastY = ypos;

	if (firstMouse)
	{
		firstMouse = false;
		return;
	}

	if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS)
		camera.processMouseMovement(xoffset, yoffset);
}

void DemoWorld::scrollCallback(GLFWwindow* window, double xoffset, double yoffset)
{
	if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS)
		lightPitch = glm::mod(lightPitch + yoffset / 100., glm::pi<double>());
	else if (glfwGetKey(window, GLFW_KEY_LEFT_ALT) == GLFW_PRESS)
		lightYaw = glm::mod(lightYaw + yoffset / 100., 2 * glm::pi<double>());
	else if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS)
		light.radiance = glm::clamp((light.radiance / lightColor).x + (float)yoffset, 0.f, 100.f) * lightColor;
	else if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
		RenderingSystem::instance().exposure = glm::clamp(RenderingSystem::instance().exposure + (float)yoffset*0.1f, 0.f, 2.f);
	else camera.processMouseScroll(yoffset);

	light.lightDirection = glm::normalize(glm::vec3((cos(lightPitch) * cos(lightYaw)), (sin(lightPitch)), (cos(lightPitch) * sin(lightYaw))));
}

void DemoWorld::processInput(GLFWwindow* window, float deltaTime)
{
	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
		camera.processKeyboard(FORWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
		camera.processKeyboard(BACKWARD, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
		camera.processKeyboard(LEFT, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
		camera.processKeyboard(RIGHT, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
		camera.processKeyboard(UP, deltaTime);
	if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
		camera.processKeyboard(DOWN, deltaTime);
}