void SilhouetteExtractor::drawTerrainWireFrame(float precision)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_POINTS); drawTerrain(); return;
// glBegin(GL_QUADS);
// for (int j = 0; j < terrain_->height()-1; ++j)
// for (int i = 0; i < terrain_->width()-1; ++i)
// {
// int nsteps = 1.0/precision;
// glNormal3fv(terrain_->getGridNormal(i, j).data());
// for (int n = 0; n < nsteps; ++n)
// for (int m = 0; m < nsteps; ++m)
// {
// float minx = i+precision*m;
// float maxx = i+precision*(m+1);
// float miny = j+precision*n;
// float maxy = j+precision*(n+1);
// glVertex3fv(Eigen::Vector3f(minx, miny, terrain_->getAltitude(minx, miny)).data());
// glVertex3fv(Eigen::Vector3f(maxx, miny, terrain_->getAltitude(maxx, miny)).data());
// glVertex3fv(Eigen::Vector3f(maxx, maxy, terrain_->getAltitude(maxx, maxy)).data());
// glVertex3fv(Eigen::Vector3f(minx, maxy, terrain_->getAltitude(minx, maxy)).data());
// }
// }
// glEnd();
}
void testApp::draw(){
if(bEdit)
ofBackgroundGradient(ofColor::gray, ofColor::black);
else
ofBackground(ofColor::black);
if (bCalibrated && bTerrain){
ofPushMatrix();
ofSetColor(255,255);
cam.begin();
ofEnableLighting();
light.enable();
drawTerrain();
light.disable();
ofDisableLighting();
cam.end();
ofPopMatrix();
}
ofSetColor(255,255);
composer.draw();
if(bEdit)
data.draw();
}
void View::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
paintSkyBoxGL();
drawTerrain();
paintStatues();
paintParticlesGL();
}
void display(void)
{
//mydisplay();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
camera();
glRotatef(-angleZ, 0.0f, 0.0f, 1.0f);
glRotatef(-angleY, 1.0f, 0.0f, 0.0f);
glRotatef(-_angleX, 0.0f, 1.0f, 0.0f);
glTranslatef(McamX, 0, McamY);
initilizeTexture(image1);
drawTerrain();
//Write your code here
initilizeTexture(image2);
drawLand();
initilizeTexture(image3);
drawWorld();
glutSwapBuffers();
}
void renderScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
fpsCurrentTime = glfwGetTime();
noFrames++;
if (fpsCurrentTime - fpsLastTime >= 1.0) {
myfile << "ms/frame " << 1000.0 / double(noFrames) << std::endl;
noFrames = 0;
fpsLastTime += 1.0;
}
drawCubeMap();
drawTerrain();
drawVegetation();
doMovements();
glutSwapBuffers();
lastTime = currentTime;
}
void drawSceneToTexture(GLuint tex, GLfloat ex, GLfloat ey, GLfloat ez, GLfloat cx, GLfloat cy, GLfloat cz) {
glBindFramebuffer(GL_FRAMEBUFFER, tex);
glClearColor(0.0, 1.0, 1.0, 0.0);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport (0, 0, G_Width, G_Height);
setProjection (1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt ( ex, ey, ez,
cx, cy, cz,
0.0, 1.0, 0.0);
glDisable(GL_TEXTURE_2D);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf ("Framebuffer ist nicht korrekt! \n");
}
drawTerrain();
}
void renderFrame(XStuff* xs, GameState* gs, InputState* is) {
//mModel = IDENT_MATRIX;
gs->sunNormal.x = cos(gs->frameTime * gs->sunSpeed);
gs->sunNormal.y = sin(gs->frameTime * gs->sunSpeed);
gs->sunNormal.z = 0.0;
//mScale3f(10, 10, 10, &mModel);
//mRot3f(0, 1, 0, gs->direction, &mModel);
msPush(&gs->proj);
msPerspective(60, gs->screen.aspect, nearPlane, farPlane, &gs->proj);
msPush(&gs->view);
// order matters! don't mess with this.
msTrans3f(0, -1, gs->zoom, &gs->view);
msRot3f(1, 0, 0, F_PI / 6, &gs->view);
msRot3f(0,1,0, gs->direction, &gs->view);
msTrans3f(-gs->lookCenter.x, 0, -gs->lookCenter.y, &gs->view);
// y-up to z-up rotation
msRot3f(1, 0, 0, F_PI_2, &gs->view);
msScale3f(1, 1, -1, &gs->view);
// calculate cursor position
Vector cursorp;
Vector eyeCoord;
Vector worldCoord;
Matrix p, invp, invv;
// device space (-1:1)
Vector devCoord;
devCoord.x = 0.50;
devCoord.y = 0.50;
devCoord.z = -1.0;
// eye space
mInverse(msGetTop(&gs->proj), &invp);
vMatrixMul(&devCoord, &invp, &eyeCoord);
vNorm(&eyeCoord, &eyeCoord);
// world space
mInverse(msGetTop(&gs->view), &invv);
vMatrixMul(&eyeCoord, &invv, &worldCoord);
vNorm(&worldCoord, &worldCoord);
// mFastMul(msGetTop(&gs->view), msGetTop(&gs->proj), &mp);
// mInverse(&mp, &invmp);
// vMatrixMul(&devCoord, &invmp, &cursorp);
//printf("(%f, %f, %f)\n", worldCoord.x, worldCoord.y, worldCoord.z);
Vector2 c2;
c2.x = 300; //cursorp.x;
c2.y = 300; //cursorp.z;
// draw terrain
// drawTerrainBlock(&gs->map, msGetTop(&gs->model), msGetTop(&gs->view), msGetTop(&gs->proj), &gs->cursorPos);
drawTerrain(&gs->map, msGetTop(&gs->view), msGetTop(&gs->proj), &gs->cursorPos, &gs->screen.wh);
renderMarker(gs, 0,0);
msPop(&gs->view);
msPop(&gs->proj);
glUseProgram(textProg->id);
// text stuff
textProj = IDENT_MATRIX;
textModel = IDENT_MATRIX;
mOrtho(0, gs->screen.aspect, 0, 1, -1, 100, &textProj);
//mScale3f(.5,.5,.5, &textProj);
mScale3f(.06, .06, .06, &textModel);
GLuint tp_ul = glGetUniformLocation(textProg->id, "mProj");
GLuint tm_ul = glGetUniformLocation(textProg->id, "mModel");
GLuint ts_ul = glGetUniformLocation(textProg->id, "fontTex");
glUniformMatrix4fv(tp_ul, 1, GL_FALSE, textProj.m);
glUniformMatrix4fv(tm_ul, 1, GL_FALSE, textModel.m);
glexit("text matrix uniforms");
glDisable(GL_CULL_FACE);
glActiveTexture(GL_TEXTURE0);
glexit("active texture");
glUniform1i(ts_ul, 0);
glexit("text sampler uniform");
glBindTexture(GL_TEXTURE_2D, arial->textureID);
glexit("bind texture");
glBindVertexArray(strRI->vao);
glexit("text vao bind");
glBindBuffer(GL_ARRAY_BUFFER, strRI->vbo);
glexit("text vbo bind");
glDrawArrays(GL_TRIANGLES, 0, strRI->vertexCnt);
glexit("text drawing");
}
void display()
{
displayPrev = displayCurrent;
displayCurrent = clock();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (drawHeightmapFlag){
drawHeightmap();
glutSwapBuffers();
return;
}
if (drawFogFlag){
glEnable(GL_FOG);
glFogf(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.008);
GLfloat fogColor[4] = { 0.3f, 0.3f, 0.3f, 1.0f }; // Fog Color
glFogfv(GL_FOG_COLOR, fogColor);
}
else{
glDisable(GL_FOG);
}
//Vale tin kamera
glLoadIdentity();
gluLookAt(cameraPosition[0], cameraPosition[1], cameraPosition[2],
0, 0, 0,
0, 1, 0);
//Draw Skybox
if (drawSkyboxFlag){
drawSkybox();
}
// Draw Terrain
drawTerrain();
//Draw Sea
if (drawSeaFlag){
drawSea();
}
drawSun();
//Add Light
glEnable(GL_NORMALIZE);
glEnable(GL_LINEAR_ATTENUATION);
glShadeModel(GL_SMOOTH);
float zeros[3] = { 0, 0, 0 };
glMaterialfv(GL_FRONT, GL_EMISSION, zeros);
GLfloat lightPos[] = { lightPosition[0], lightPosition[1], lightPosition[2], 1 };
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glutSwapBuffers();
}
int main()
{
arr = (unsigned int**)malloc(4377 * sizeof(unsigned int));
psController ps;
int velocity = 0;
int angle = 0;
long ii = 0;
int** collisionMatrix;
int ee;
int numfiles;
char * filenames[MAXFILES];
//init_VGA_Pixel();
initVGA(); //pixel
init_VGA_Char();
av_config_setup();
numfiles = init_sd(filenames);
init_wav(arr);
printf("timing audio\n");
//time_of_sound = time_audio(arr);
printf("looping audio\n");
audio_isr_k = 0;
alt_irq_register(AUDIO_IRQ, NULL, &audio_isr);
alt_up_audio_enable_write_interrupt(audio);
//====INITIALIZE AND DRAW TERRAIN USING BMP ===========================//
short int fd;
terrain background;
fd = alt_up_sd_card_fopen("bg.bmp", false);
initTerrain(fd, &background);
drawBackground(background);
alt_up_sd_card_fclose(fd);
terrain terrain;
fd = alt_up_sd_card_fopen("tr.bmp", false);
initTerrain(fd, &terrain);
drawTerrain(terrain);
alt_up_sd_card_fclose(fd);
//====INITIALIZE AND DRAW USER TANK USING BMP ===========================//
fd = alt_up_sd_card_fopen("tank.bmp", false);
tank user;
initUserTank(&user, fd);
drawTank(&user, background);
alt_up_sd_card_fclose(fd);
//====INITIALIZE AND DRAW ENEMY TANK USING BMP ===========================//
tank enemy;
fd = alt_up_sd_card_fopen("tk.bmp", false);
initEnemyTank1(&enemy, fd);
drawTank(&enemy,background);
alt_up_sd_card_fclose(fd);
//====SWAP BUFFERS =======================================================//
updateVGA();
drawBackground(background);
drawTerrain(terrain);
drawTank(&enemy, background);
for(ee=0;ee < 20;ee++)
{
moveTank(&user, RIGHT, 1);
drawTank(&user,background);
updateVGA();
drawTank(&user,background);
//delay();
}
//for(ii = 0; ii < 300000; ii++);
collisionMatrix = init_CollisionMatrix(XMAXSCREEN_RESOLUTION + 1, XMAXSCREEN_RESOLUTION + 1);
//alt_up_pixel_buffer_dma_draw_box(pixel_buffer, 0, 120, 340, 240, 0x7E0 , 0); //draw terrain
set_CollisionAtRectArea(collisionMatrix, 0 , 0, 340, 240, EMPTY);
set_CollisionAtRectArea(collisionMatrix, 0 , 161, 340, 240, TERRAIN_COLOR);//set the rectangular area drawn by terrain to filled with terrain
while(1){
//angle = 0;
velocity = 0;
set_UserTank(&angle, &velocity, ps, &user, &enemy, background); //reads controller to set angle, power, and shoot
shoot_Missile(angle, velocity,( user.x + user.t_VGA.width) - 1 , (240 - user.y + user.t_VGA.height) - 7, collisionMatrix, background);
}
clean_audio(arr);
return 0;
}
void SilhouetteExtractor::computeVisibleFrontFacingStatus()
{
int terrain_width = terrain_->width();
int terrain_height = terrain_->height();
delete front_facing_;
front_facing_ = new FacingMode [(terrain_width-1)*(terrain_height-1)];
bool use_intersections = true ;
if (!use_intersections)
{
setupPixelBuffer();
pixelbuffer_->makeCurrent();
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
GLfloat lightpos[] = {.5, 1., 1., 0.};
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawTerrain();
updateMatrices();
saveBuffer("test_dpth.png");
pixelbuffer_->makeCurrent();
}
double begin = omp_get_wtime();
int i = 0;
#pragma omp parallel for private(i)
for (int j = 0; j < terrain_->height()-1; ++j)
for (i = 0; i < terrain_->width()-1; ++i)
{
front_facing_[j*(terrain_width-1)+i] = kInvisible;
Eigen::Vector3f center = getFaceCentroid(i, j);
Eigen::Vector3f projector = center - camera_info_.position;
//projector = camera_info_.direction;
float theta = acos(camera_info_.direction.normalized().dot(projector.normalized()));
if (theta > camera_info_.fov_in_rads/2)
continue;
front_facing_[j*(terrain_width-1)+i] = kBackFacing;
if (terrain_->getGridNormal(i, j).dot(projector) <= -FLT_EPSILON)
{
if (use_intersections)
{
if (checkVisibility(center))
front_facing_[j*(terrain_width-1)+i] = kFrontFacing;
} else
{
Eigen::Vector3d window_coords;
gluProject(center[0], center[1], center[2],
modelview_matrix_, projection_matrix_, viewport_,
&window_coords[0], &window_coords[1], &window_coords[2]);
if (window_coords[0] < 0 || window_coords[1] < 0 || window_coords[0] >= width() || window_coords[1] >= height())
continue;
float depth = 0.0;
glReadPixels(window_coords[0], window_coords[1], 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
if (std::abs(depth-window_coords[2]) < 1e-3)
front_facing_[j*(terrain_width-1)+i] = kFrontFacing;
}
}
}
double end = omp_get_wtime();
double elapsed_secs = double(end - begin);
fprintf(stdout, "Elapsed time for checking front/back facing: %.2f secs\n", elapsed_secs);
fprintf(stdout, "Num of threads: %d threads\n", omp_get_thread_num());
fflush(stdout);
if (pixelbuffer_)
{
pixelbuffer_->doneCurrent();
cleanupPixelBuffer();
}
}
int game(SHIP ship, int seed) {
srand(seed);
int gamestate = DRAWINIT;
int screenWidth = 240;
int screenHeight = 160;
int lives = 5;
int timer = 0;
int gravity = 1;
int playing = 1;
// Create old ship
SHIP shipbase = ship;
SHIP oldship = ship;
// Create landing pad
LANDINGPAD p = createLandingPad(ship);
// Create terrain
int NUMTERRAIN = screenWidth;
TERRAIN *terrain = generateTerrain(p);
int i;
// Game Loop
while(1){
switch(gamestate) {
case PAUSE:
while(!(KEY_DOWN_NOW(BUTTON_LEFT) ||
KEY_DOWN_NOW(BUTTON_RIGHT) ||
KEY_DOWN_NOW(BUTTON_UP)||
KEY_DOWN_NOW(BUTTON_SELECT)));
if(KEY_DOWN_NOW(BUTTON_LEFT) ||
KEY_DOWN_NOW(BUTTON_RIGHT) ||
KEY_DOWN_NOW(BUTTON_UP));
{
gamestate = DRAWINIT;
}
// Return to title when select is pressed
if(KEY_DOWN_NOW(BUTTON_SELECT))
{
return TITLE;
}
playing = 1;
gamestate = START;
break;
case DRAWINIT:
// Set initial background
DMA[3].src = BG;
DMA[3].dst = videoBuffer;
DMA[3].cnt = DMA_ON | 38400;
// Draw the ship
drawShip(ship);
// Draw Lives
drawLives(lives);
// Draw the landing pad
drawRect(p.row, p.col, p.length, p.width, p.color);
// Draw the terrain
drawTerrain(terrain);
gamestate = PAUSE;
break;
case START:
while(playing) {
/////////////////// BUTTON CONTROLS //////////////////
// Return to title when select is pressed
if(KEY_DOWN_NOW(BUTTON_SELECT))
{
return TITLE;
}
// Left movement
if(KEY_DOWN_NOW(BUTTON_LEFT) && ship.fuel > 0)
{
if(ship.col > 0)
{
ship.col-=ship.cdel;
ship.fuel--;
}
}
// Right movement
if(KEY_DOWN_NOW(BUTTON_RIGHT) && ship.fuel > 0)
{
if(ship.col+ship.width < screenWidth)
{
ship.col+=ship.cdel;
ship.fuel--;
}
}
// Account for gravity and thrust
if(KEY_DOWN_NOW(BUTTON_UP) && ship.fuel > 0)
{
if(timer > 5)
{
timer = 0;
ship.rdel-=ship.thrust;
}
else
{
timer++;
}
ship.row+=ship.rdel;
ship.fuel--;
}
else
{
ship.row+=ship.rdel;
if(timer > 5)
{
timer = 0;
ship.rdel+=gravity;
}
else
{
timer++;
}
}
waitForVblank();
///////////////////////// Collision Check //////////////////////////
// Check pad landing
if((ship.row+ship.length >= p.row) &&
(ship.row+ship.length/2 < p.row+p.length) &&
(ship.col+ship.width/2 > p.col) &&
(ship.col-ship.width/2 < p.col + p.width))
{
ship.row = p.row - ship.length;
clearShip(oldship);
drawShip(ship);
return WIN;
}
// Check ground collision
if((ship.row+ship.length >= screenHeight) && lives > 0)
{
clearShip(oldship);
ship = shipbase;
lives--;
clearLives(lives);
oldship = ship;
gamestate = PAUSE;
playing = 0;
}
// Check terrain collision
for (i = 0; i < NUMTERRAIN; i += 1)
{
if((ship.row+ship.length >= terrain[i].row) && (ship.col+ship.width > terrain[i].col) &&
(ship.col < terrain[i].col + terrain[i].width) && (ship.row <= terrain[i].row+terrain[i].length))
{
clearShip(oldship);
ship = shipbase;
lives--;
clearLives(lives);
oldship = ship;
gamestate = PAUSE;
playing = 0;
}
}
// Draw if more lives after collision
if(lives > 0)
{
// Draw lives
drawLives(lives);
// Draw the ship
clearShip(oldship);
drawShip(ship);
}
// Check lives
if(lives <= 0)
{
clearShip(oldship);
drawShip(ship);
return LOSE;
}
oldship = ship;
}
break;
}
}
return TITLE;
}
void TerrainTessellation::draw(void)
{
glClearColor( 0.7f, 0.8f, 1.0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
//
// Compute matrices without the legacy matrix stack support
//
nv::matrix4f projectionMatrix;
nv::perspective( projectionMatrix, 45.0f * 2.0f*NV_PI / 360.0f, (float)m_width/(float)m_height, 0.01f, 100.0f);
nv::matrix4f invProjection = nv::inverse(projectionMatrix);
nv::matrix4f viewMatrix;
viewMatrix = m_transformer->getModelViewMat();
nv::matrix4f invView = nv::inverse(viewMatrix);
// compute frustum planes for culling
nv::vec4f frustumPlanes[6];
computeFrustumPlanes(viewMatrix, projectionMatrix, frustumPlanes);
glViewport(0, 0, m_width, m_height);
glBindProgramPipeline(0);
//
// update struct representing UBO
//
mParams.ModelView = viewMatrix;
mParams.ModelViewProjection= projectionMatrix * viewMatrix;
mParams.Projection = projectionMatrix;
mParams.InvProjection = invProjection;
mParams.InvView = invView;
mParams.cull = mCull;
mParams.lod = mLod;
mParams.viewport = nv::vec4f(0.0, 0.0, (float) m_width, (float) m_height);
mParams.lightDirWorld = mLightDir;
mParams.lightDir = nv::vec3f(viewMatrix * nv::vec4f(normalize(mLightDir), 0.0)); // transform to eye space
mParams.smoothNormals = mSmoothNormals;
mParams.time = mTime;
mParams.eyePosWorld = invView * nv::vec4f(0.0f, 0.0f, 0.0f, 1.0f);
if (mAnimate) {
mParams.translate.y -= getFrameDeltaTime()*2.0f;
}
for(int i=0; i<6; i++) {
mParams.frustumPlanes[i] = frustumPlanes[i];
}
// bind the buffer for the UBO, and update it with the latest values from the CPU-side struct
glBindBufferBase( GL_UNIFORM_BUFFER, 1, mUBO);
glBindBuffer( GL_UNIFORM_BUFFER, mUBO);
glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(TessellationParams), &mParams);
// enable / disable wireframe
glPolygonMode( GL_FRONT_AND_BACK, mWireframe ? GL_LINE : GL_FILL);
// query number of primitives
glBeginQuery(GL_PRIMITIVES_GENERATED, mGPUQuery);
drawTerrain();
glEndQuery(GL_PRIMITIVES_GENERATED);
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
drawSky();
// update triangle count so we can display in UI
glGetQueryObjectuiv(mGPUQuery, GL_QUERY_RESULT, &mNumPrimitives);
mStatsText->SetValue(mNumPrimitives);
if (mReload) {
loadShaders();
mReload = false;
mTweakBar->syncValues();
}
}
void display(void)
{
curTime = timeGetTime();
float dt = (float)(curTime - lastTime) * 0.001;//secに変換
elapseTime1 += dt;
elapseTime2 += dt;
fps ++;
if(elapseTime1 >= 1.0)
{
printf("frame per sec = %d \n", fps);
elapseTime1 = 0.0;
fps = 0;
}
lastTime = curTime;
//カラーバッファ,デプスバッファのクリア
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();//視点を変えるときはこの位置に必要
if(cos(M_PI * view.theta /180.0) >= 0.0)//カメラ仰角90度でﾋﾞｭｰｱｯﾌﾟﾍﾞｸﾄﾙ切替
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, 1.0, 0.0);
else
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, -1.0, 0.0);
//光源設定//'l'を押した後光源位置可変
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texName[0]);
//描画
// シェーダプログラムの適用
glUseProgram(shaderProg);
//テクスチャユニットをシェーダ側のサンプラに関連付け,レンダリング
GLint texLoc = glGetUniformLocation(shaderProg, "tex");
glUniform1i(texLoc, 0);//GL_TEXTURE0を適用
GLint timeLoc = glGetUniformLocation(shaderProg, "time");
glUniform1f(timeLoc, elapseTime2);//経過時間(sec)
drawTerrain();
// シェーダプログラムの適用を解除
glUseProgram(0);
//particle
glBindTexture(GL_TEXTURE_2D, texName[1]);
drawParticle(dt);
if(flagHelp)
{
printf("矢印キーによるアフィン変換/光源移動 \n");
printf(" →,←：x軸 \n");
printf(" ↑,↓：y軸 \n");
printf(" [Shift]＋↑,↓：z軸 \n");
printf(" 'r'を押した後:回転 \n");
printf(" 't'を押した後:平行移動 \n");
printf(" 's'を押した後:ｽｹｰﾘﾝｸﾞ \n");
printf(" 'l'を押した後、光源位置の移動可 \n");
printf("マウス操作で視点変更可 \n");
printf(" dolly：中央付近を左ボタンクリックで近づき，右ボタンクリックで遠ざかる \n");
printf(" pan：左横および右横を右ボタンクリックで注視点が左右に変化する \n");
printf(" tilt：真上および真下を右ボタンクリックで注視点が上下に変化する \n");
printf(" tumble：左右にドラッグすると視点が左右に変化する \n");
printf(" crane：上下にドラッグすると視点が上下に変化する \n");
printf(" zoom：左下を右ボタンクリックでズームイン \n");
printf(" 右下を右ボタンクリックでズームアウト \n");
printf("[Shift]+'r'でリセット \n");
printf("[F1]キー：βの調整 \n");
printf("[F2]キー：σの調整 \n");
printf("[F3]キー：seedの変更 \n");
printf("[F4]キー：x方向の風力変更 \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
void display(void)
{
curTime = timeGetTime();
float dt = (float)(curTime - lastTime) * 0.001;//secに変換
elapseTime1 += dt;
elapseTime2 += dt;
fps ++;
if(elapseTime1 >= 1.0)
{
printf("frame per sec = %d \n", fps);
elapseTime1 = 0.0;
fps = 0;
}
lastTime = curTime;
//カラーバッファ,デプスバッファのクリア
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();//視点を変えるときはこの位置に必要
if(cos(M_PI * view.theta /180.0) >= 0.0)//カメラ仰角90度でﾋﾞｭｰｱｯﾌﾟﾍﾞｸﾄﾙ切替
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, 1.0, 0.0);
else
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, -1.0, 0.0);
//光源設定//'l'を押した後光源位置可変
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
if(flagWireframe)//'w'でwireframeとsolid model切り替え
{
glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_POINT);
}
else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
//描画
// シェーダプログラムの適用
glUseProgram(shaderProg);
//テクスチャユニットをシェーダ側のサンプラに関連付け,レンダリング
//fragment shaderのユニフォーム変数texのインデックスを取得
GLint texLoc = glGetUniformLocation(shaderProg, "tex");
glUniform1i(texLoc, 0);//GL_TEXTURE0を適用
drawTerrain();
// シェーダプログラムの適用を解除
glUseProgram(0);
drawParticle(dt);
drawParticle2(dt);
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_FALSE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧを書き込み禁止
glEnable(GL_BLEND);//ｱﾙﾌｧﾌﾞﾚﾝﾃﾞｨﾝｸﾞを有効にする
glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_SRC_ALPHA);//色混合係数を決める
//半透明描画
makeRiver(elapseTime2);
drawRiver();
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_TRUE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧの書き込みを許可
glDisable(GL_BLEND);
if(flagHelp)
{
printf("矢印キーによるアフィン変換/光源移動 \n");
printf(" →,←：x軸 \n");
printf(" ↑,↓：y軸 \n");
printf(" [Shift]＋↑,↓：z軸 \n");
printf(" 'r'を押した後:回転 \n");
printf(" 't'を押した後:平行移動 \n");
printf(" 's'を押した後:ｽｹｰﾘﾝｸﾞ \n");
printf(" 'l'を押した後、光源位置の移動可 \n");
printf("'w'でﾜｲﾔｰﾌﾚｰﾑとｿﾘｯﾄﾞﾓﾃﾞﾙ切り替え \n");
printf("マウス操作で視点変更可 \n");
printf(" dolly：中央付近を左ボタンクリックで近づき，右ボタンクリックで遠ざかる \n");
printf(" pan：左横および右横を右ボタンクリックで注視点が左右に変化する \n");
printf(" tilt：真上および真下を右ボタンクリックで注視点が上下に変化する \n");
printf(" tumble：左右にドラッグすると視点が左右に変化する \n");
printf(" crane：上下にドラッグすると視点が上下に変化する \n");
printf(" zoom：左下を右ボタンクリックでズームイン \n");
printf(" 右下を右ボタンクリックでズームアウト \n");
printf("[Shift]+'r'でリセット \n");
printf("[F1]キー：βの調整 \n");
printf("[F2]キー：σの調整 \n");
printf("[F3]キー：seedの変更 \n");
printf("[F4]キー：x方向の風力変更 \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
