//Procedimento que gerencia o elevador emitindo sinais na Porta Paralela
void toMove (int value)
{
if (value > position) //Para subir
{
printf ("Subindo.\n");
while (value > position) //Enquanto nao chegar ao destino
{
outb(PINO3, LPT); //para subir
usleep(TIMEUP); //Tempo em segundos
position++; //Incrementa 1 � posi��o atual
viewPosition(); //Chama o procedimento para exibir a posi��o
}
}
else if (value < position) //Para descer
{
printf("Descendo.\n");
while (value < position)
{
outb(PINO2, LPT); //para descer, liga pino 2 e apaga pino 3
usleep(TIMEDOWN);
position--; //Decrementa 1 � posi��o atual
viewPosition();
}
}
}
//聚光灯（边缘软化）
void LightCasterStudy::render()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
double currentTime = glfwGetTime();
spotLightShader->UseProgram();
vec3 lightPos(3.0f, 0.0f, 0.0f);
vec3 viewPosition(0.0f, 0.0f, 5.0f);
vec3 lightDirection(0.0f, 0.0f, -1.0f);
auto tempValue = dot(normalize(viewPosition - vec3(1.0f, 0.0f, 0.0f)), normalize(-lightDirection));
//glm::cos 中的参数为弧度，非角度（有点坑），需要用radians进行角度转换。
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, this->cubeDiffuseTexture);
glUniform1i(glGetUniformLocation(spotLightShader->getProgram(), "material.diffuse"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, this->cubeSpecularTexture);
glUniform1i(glGetUniformLocation(spotLightShader->getProgram(), "material.specular"), 1);
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "material.shininess"), 0.6f * 128.0f);
glUniform3fv(glGetUniformLocation(spotLightShader->getProgram(), "light.direction"), 1, value_ptr(lightDirection));
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "light.cutOff"), glm::cos(glm::radians(12.5f)));
glUniform3f(glGetUniformLocation(spotLightShader->getProgram(), "light.ambient"), 0.1f, 0.1f, 0.1f);
glUniform3f(glGetUniformLocation(spotLightShader->getProgram(), "light.specular"), 1.0f, 1.0f, 1.0f);
glUniform3f(glGetUniformLocation(spotLightShader->getProgram(), "light.diffuse"), 1.0f, 1.0f, 1.0f);
glUniform3fv(glGetUniformLocation(spotLightShader->getProgram(), "light.position"), 1, value_ptr(viewPosition));
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "light.outerCutOff"), glm::cos(glm::radians(17.0f)));
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "light.constant"), 1.0f);
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "light.linear"), 0.09f);
glUniform1f(glGetUniformLocation(spotLightShader->getProgram(), "light.quadratic"), 0.032f);
glUniform3f(glGetUniformLocation(spotLightShader->getProgram(), "lightcolor"), 1.0f, 1.0f, 1.0f);
glUniform3fv(glGetUniformLocation(spotLightShader->getProgram(), "viewPos"), 1, value_ptr(viewPosition));
mat4 model(1.0);
mat4 view(1.0);
mat4 projection(1.0);
RenderDelegate::getInstance()->printProgramInfoLog(spotLightShader->getProgram());
view = lookAt(viewPosition, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
projection = perspective(radians(45.0f), 800.0f / 600.0f, 0.1f, 1000.0f);
glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "view"), 1, GL_FALSE, value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "projection"), 1, GL_FALSE, value_ptr(projection));
glBindVertexArray(this->cubeVAO);
for(GLuint i = 0; i < 10; i++)
{
model = glm::translate(mat4(1.0f), cubePositions[i]);
GLfloat angle = (i + 1) * currentTime * 5.0f;
model = glm::rotate(model, radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));
glUniformMatrix4fv(glGetUniformLocation(cubeShader->getProgram(), "model"), 1, GL_FALSE, glm::value_ptr(model));
glDrawArrays(GL_TRIANGLES, 0, 36);
}
glBindVertexArray(0);
}
//Fun��o principal
int main ()
{
if (ioperm (LPT, 3, 1) == 1) //Ativa e verifica a Porta Paralela
{
printf ("Erro ao acessar o endere�o 0x378 (Porta Paralela).\n");
exit (1); //Em caso de erro
}
viewPosition(); //Exibe a posi��o atual (no caso T�rreo)
console(); //Chama o console do elevador
outb(STOP, LPT);
ioperm(LPT, 3, 0); //Desativa a Porta Paralela
return 0; //Fim do programa
}
// ----------------------------------------------------------------------------
bool App::OnInit()
{
sf::RenderWindow m_Window(sf::VideoMode(800, 600), "Game of Life");
// list of objects to render every frame
std::vector<Drawable*> renderList;
// initialise background
float zoomLimitMax = 2.0f;
float zoomLimitMin = 0.125f;
float zoomSmoothnessFactor = 4.0f;
Background background;
background.generate();
renderList.push_back( &background );
// initialise cell field
bool mouseMoveKills = false;
CellField cellField;
renderList.push_back( &cellField );
// set up zooming parameters
float currentZoom = 1.0f, targetZoom = 1.0f;
sf::Vector2f viewPosition(0.0f,0.0f);
sf::Vector2i pinchScrollPosition;
bool isScrolling = false;
// mouse states
sf::Vector2i mousePosition;
bool mouseButton1 = false;
// cell timer, keeps track of when to update to next frame
int cellTimer = 0;
// speed of simulation
int simulationSpeed = 5;
// set to true when the game is paused
bool isPaused = true;
// set up loop timer
LoopTimer loopTimer;
loopTimer.setFPS( 60 );
// run the program as long as the window is open
while( m_Window.isOpen() )
{
// update game logic
int maxUpdateLoops = 0;
while( loopTimer.isTimeToUpdate() )
{
// smooth zooming
float deltaZoom = (currentZoom-targetZoom)/zoomSmoothnessFactor;
currentZoom -= deltaZoom;
// adjust view position so zoom occurs under mouse
viewPosition.x += static_cast<float>(mousePosition.x)*deltaZoom/(currentZoom*currentZoom);
viewPosition.y += static_cast<float>(mousePosition.y)*deltaZoom/(currentZoom*currentZoom);
// calculate next frame if time has come
if( !isPaused && cellTimer++ >= simulationSpeed )
{
cellTimer = 0;
cellField.calculateNextGeneration();
}
// limit amount of update loops allowed
if( ++maxUpdateLoops == 10 )
break;
}
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while( m_Window.pollEvent(event) )
{
// "close requested" event: close the window
if( event.type == sf::Event::Closed )
m_Window.close();
// handle zooming
if( event.type == sf::Event::MouseWheelMoved )
{
targetZoom += event.mouseWheel.delta/20.0f;
if( targetZoom >= zoomLimitMax ) targetZoom = zoomLimitMax;
if( targetZoom <= zoomLimitMin ) targetZoom = zoomLimitMin;
}
// mouse button pressed
if( event.type == sf::Event::MouseButtonPressed )
{
// press mouse
if( event.mouseButton.button == sf::Mouse::Left )
mouseButton1 = true;
// determine if further mouse movement should kill or revive cells
int cellX = std::floor( (static_cast<float>(event.mouseButton.x)/currentZoom-viewPosition.x)/10.0f );
int cellY = std::floor( (static_cast<float>(event.mouseButton.y)/currentZoom-viewPosition.y)/10.0f );
if( cellField.isCellAlive(GOL::Vector2<int>(cellX,cellY)) )
{
mouseMoveKills = true;
if( mouseButton1 && isPaused )
cellField.removeCell(GOL::Vector2<int>(cellX,cellY));
}else
{
mouseMoveKills = false;
if( mouseButton1 && isPaused )
cellField.addCell(GOL::Vector2<int>(cellX,cellY));
}
// begin scrolling
if( event.mouseButton.button == sf::Mouse::Right )
{
isScrolling = true;
pinchScrollPosition.x = event.mouseButton.x;
pinchScrollPosition.y = event.mouseButton.y;
}
}
// mouse button released
if( event.type == sf::Event::MouseButtonReleased )
{
// release mouse
if( event.mouseButton.button == sf::Mouse::Left )
mouseButton1 = false;
// end scrolling
if( event.mouseButton.button == sf::Mouse::Right )
isScrolling = false;
}
// mouse movement
if( event.type == sf::Event::MouseMoved )
{
// set mouse position
mousePosition.x = event.mouseMove.x;
mousePosition.y = event.mouseMove.y;
// handle scrolling
if( isScrolling )
{
viewPosition.x += static_cast<float>(event.mouseMove.x - pinchScrollPosition.x)/currentZoom;
viewPosition.y += static_cast<float>(event.mouseMove.y - pinchScrollPosition.y)/currentZoom;
pinchScrollPosition.x = event.mouseMove.x;
pinchScrollPosition.y = event.mouseMove.y;
}
// handle killing/reviving cells in edit mode
if( isPaused && mouseButton1 )
{
int cellX = std::floor( (static_cast<float>(event.mouseMove.x)/currentZoom-viewPosition.x)/10.0f );
int cellY = std::floor( (static_cast<float>(event.mouseMove.y)/currentZoom-viewPosition.y)/10.0f );
if( mouseMoveKills )
cellField.removeCell(GOL::Vector2<int>(cellX,cellY));
else
cellField.addCell(GOL::Vector2<int>(cellX,cellY));
}
}
// button presses
if( event.type == sf::Event::KeyPressed )
{
// pause/resume with space
if( event.key.code == sf::Keyboard::Space )
{
isPaused = !isPaused;
}
// increase simulation speed
if( event.key.code == sf::Keyboard::Up )
if( simulationSpeed > 0 )
--simulationSpeed;
// decrease simulation speed
if( event.key.code == sf::Keyboard::Down )
if( simulationSpeed < 60 )
++simulationSpeed;
// reset field
if( event.key.code == sf::Keyboard::Delete )
if( isPaused )
cellField.reset();
}
}
// clear
m_Window.clear();
// draw everything to render window
for( std::vector<Drawable*>::iterator it = renderList.begin(); it != renderList.end(); ++it )
(*it)->draw( &m_Window, sf::Vector2f(800,600), viewPosition, currentZoom );
// end the current frame
m_Window.display();
}
return true;
}
void TupPaintArea::mousePressEvent(QMouseEvent *event)
{
#ifdef K_DEBUG
T_FUNCINFO;
#endif
// SQA: Temporal solution for cases when there's no current frame defined
if (!graphicsScene()->currentFrame()) {
return;
}
if (graphicsScene()->currentFrame()->isLocked()) {
#ifdef K_DEBUG
tFatal() << "TupPaintArea::mousePressEvent() - Frame is locked!";
#endif
return;
}
if (k->currentTool.compare(tr("Line Selection")) == 0) {
// If a node is the target... abort!
if (event->buttons() == Qt::RightButton) {
if (qgraphicsitem_cast<TControlNode *>(scene()->itemAt(mapToScene(event->pos()))))
return;
}
}
if (k->currentTool.compare(tr("Object Selection")) == 0) {
if (event->buttons() == Qt::RightButton) {
// If a node is the target... abort!
if (qgraphicsitem_cast<Node *>(scene()->itemAt(mapToScene(event->pos()))))
return;
if (QGraphicsItem *item = scene()->itemAt(mapToScene(event->pos()))) {
if (item->opacity() == 1) {
item->setFlag(QGraphicsItem::ItemIsSelectable, true);
item->setSelected(true);
} else {
return;
}
}
QMenu *menu = new QMenu(tr("Drawing area"));
menu->addAction(kApp->findGlobalAction("undo"));
menu->addAction(kApp->findGlobalAction("redo"));
menu->addSeparator();
QAction *cut = menu->addAction(tr("Cut"), this, SLOT(cutItems()), QKeySequence(tr("Ctrl+X")));
QAction *copy = menu->addAction(tr("Copy"), this, SLOT(copyItems()), QKeySequence(tr("Ctrl+C")));
QAction *paste = menu->addAction(tr("Paste"), this, SLOT(pasteItems()), QKeySequence(tr("Ctrl+V")));
QAction *del = menu->addAction(tr("Delete"), this, SLOT(deleteItems()), QKeySequence(Qt::Key_Delete));
menu->addSeparator();
QMenu *order = new QMenu(tr("Order"));
connect(order, SIGNAL(triggered(QAction*)), this, SLOT(requestMoveSelectedItems(QAction*)));
order->addAction(tr("Send to back"))->setData(MoveBack);
order->addAction(tr("Bring to front"))->setData(MoveFront);
order->addAction(tr("Send backwards"))->setData(MoveBackwards);
order->addAction(tr("Brind forwards"))->setData(MoveForwards);
menu->addMenu(order);
order->setDisabled(true);
menu->addSeparator();
// Code commented temporary while SQA is done
QAction *addItem = menu->addAction(tr("Add to library..."), this, SLOT(addSelectedItemsToLibrary()));
menu->addSeparator();
if (scene()->selectedItems().isEmpty()) {
del->setEnabled(false);
cut->setEnabled(false);
copy->setEnabled(false);
addItem->setEnabled(false);
} else {
QList<QGraphicsItem *> selected = scene()->selectedItems();
foreach (QGraphicsItem *item, selected) {
QDomDocument dom;
dom.appendChild(dynamic_cast<TupAbstractSerializable *>(item)->toXml(dom));
QDomElement root = dom.documentElement();
if (root.tagName() == "symbol") {
QString key = root.attribute("id").toUpper();
if (key.endsWith("JPG") || key.endsWith("PNG") || key.endsWith("GIF") || key.endsWith("XPM")) {
addItem->setEnabled(false);
break;
}
} else if (root.tagName() == "svg") {
addItem->setEnabled(false);
break;
}
}
}
if (k->copiesXml.isEmpty())
paste->setEnabled(false);
if (QMenu *toolMenu = graphicsScene()->currentTool()->menu()) {
menu->addSeparator();
menu->addMenu(toolMenu);
}
k->position = viewPosition();
k->menuOn = true;
menu->exec(event->globalPos());
}
}
void Game::MainLoop()
{
sf::Clock FPSClock;
map = new tmx::MapLoader("maps/");
map->Load("map_test.tmx");
sf::Clock frameClock;
sf::Time frameTime;
view.reset(sf::FloatRect(0, 0, 800/2, 600/2));
view.setViewport(sf::FloatRect(0, 0, 1.0f, 1.0f));
sf::Vector2f viewPosition(800 / 2, 600 / 2);
view.zoom(0.6f);
sf::Clock clock;
sf::Time timeSinceLastUpdate = sf::Time::Zero;
//sf::SoundBuffer *mainThemeBuffer;
mainThemeBuffer = new sf::SoundBuffer();
if (!mainThemeBuffer->loadFromFile("audio/main.wav"))
{
std::cout << "Failed to load mainTheme.wav" << std::endl;
delete mainThemeBuffer;
mainThemeBuffer = 0;
}
main = new sf::Sound(*mainThemeBuffer);
main->setLoop(true);
main->setVolume(75.0f);
//main->play();
layers = map->GetLayers();
hBar = new HealthBar(view.getCenter());
while(wnd->isOpen())
{
if (currentState == GameStates::PLAYING)
{
sf::Time elapsedTime = clock.restart();
timeSinceLastUpdate += elapsedTime;
while (timeSinceLastUpdate > TimePerFrame)
{
timeSinceLastUpdate -= TimePerFrame;
//Update logic
mPlayer->Update(TimePerFrame);
hBar->Update(TimePerFrame);
for (size_t i = 0; i < slimes.size(); i++)
slimes.at(i)->Update(TimePerFrame);
for (size_t i = 0; i < items.size(); i++)
items.at(i)->Update(TimePerFrame);
for (size_t i = 0; i < fireMonsters.size(); i++)
fireMonsters.at(i)->Update(TimePerFrame);
}
//Collision Detection
HandleCollision();
hBar->SetHealthState(mPlayer->GetHealth());
if (mPlayer->getPosition().x > 120 && mPlayer->getPosition().x < 2278)
view.setCenter(mPlayer->getPosition().x, mPlayer->getPosition().y - 30);
else
{
if (mPlayer->getPosition().x < 2278)
view.setCenter(120, mPlayer->getPosition().y - 30);
else
view.setCenter(2278, mPlayer->getPosition().y - 30);
}
hBar->setPosition(view.getCenter().x - 105, view.getCenter().y - 75);
wnd->setView(view);
if (mPlayer->Succeded() || mPlayer->Dead())
main->stop();
}
else
{
timeSinceLastUpdate = sf::Time::Zero;
clock.restart();
}
HandleInput();
Draw();
}
}
// ----------------------------------------------------------------------------
void App::go()
{
// list of objects to render every frame
std::vector<Drawable*> renderList;
// set up zooming parameters
float zoomLimitMax = 2.0f;
float zoomLimitMin = 0.125f;
float zoomSmoothnessFactor = 4.0f;
float currentZoom = 1.0f, targetZoom = 1.0f;
sf::Vector2f viewPosition(0.0f,0.0f);
sf::Vector2i pinchScrollPosition;
bool isScrolling = false;
// mouse states
sf::Vector2i mousePosition;
bool mouseButton1 = false;
// create some lines
LineStripBatch room;
room.addPoint( sf::Vector2f(10,10) );
room.addPoint( sf::Vector2f(100,100) );
renderList.push_back( &room );
// open render window
Window window;
window.open( "window.cfg", "Unilluminable Room Simulation" );
// set up loop timer
LoopTimer loopTimer;
loopTimer.setFPS( 60 );
// run the program as long as the window is open
while (window.getRenderWindow()->isOpen())
{
// update game logic
int maxUpdateLoops = 0;
while( loopTimer.isTimeToUpdate() )
{
// limit amount of update loops allowed
if( ++maxUpdateLoops == 10 )
break;
}
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while( window.getRenderWindow()->pollEvent(event) )
{
// "close requested" event: close the window
if( event.type == sf::Event::Closed )
window.close();
// handle zooming
if( event.type == sf::Event::MouseWheelMoved )
{
targetZoom += event.mouseWheel.delta/50.0f;
if( targetZoom >= zoomLimitMax ) targetZoom = zoomLimitMax;
if( targetZoom <= zoomLimitMin ) targetZoom = zoomLimitMin;
}
// mouse button pressed
if( event.type == sf::Event::MouseButtonPressed )
{
// begin scrolling
if( event.mouseButton.button == sf::Mouse::Right )
{
isScrolling = true;
pinchScrollPosition.x = event.mouseButton.x;
pinchScrollPosition.y = event.mouseButton.y;
}
}
// mouse button released
if( event.type == sf::Event::MouseButtonReleased )
{
// release mouse
if( event.mouseButton.button == sf::Mouse::Left )
mouseButton1 = false;
// end scrolling
if( event.mouseButton.button == sf::Mouse::Right )
isScrolling = false;
}
// mouse movement
if( event.type == sf::Event::MouseMoved )
{
// set mouse position
mousePosition.x = event.mouseMove.x;
mousePosition.y = event.mouseMove.y;
// handle scrolling
if( isScrolling )
{
viewPosition.x += static_cast<float>(event.mouseMove.x - pinchScrollPosition.x)/currentZoom;
viewPosition.y += static_cast<float>(event.mouseMove.y - pinchScrollPosition.y)/currentZoom;
pinchScrollPosition.x = event.mouseMove.x;
pinchScrollPosition.y = event.mouseMove.y;
}
}
}
// clear
window.getRenderWindow()->clear();
// create render state
sf::Transform transform;
transform.translate( viewPosition );
transform.scale( currentZoom, currentZoom );
sf::RenderStates states;
states.transform = transform;
// draw everything to render window
for( std::vector<Drawable*>::iterator it = renderList.begin(); it != renderList.end(); ++it )
(*it)->draw( window.getRenderWindow(), states );
// end the current frame
window.getRenderWindow()->display();
}
}
