void Flashlight::draw(field heroLocation, field targetLocation, SDL_Renderer* renderer)
{
///Atack
if( (SDL_GetTicks() - cooldownTimer_) < 150)
{
if(lastAttackMode_==1)
{
drawLight(heroLocation, targetLocation, renderer);
}
else if(lastAttackMode_==2)
{
drawLight(heroLocation, renderer);
}
}
///Range
if(!upgraded_)
{
SDL_Rect source={0,110,534,540};
SDL_Rect destination={heroLocation.fieldX-270, heroLocation.fieldY-270, 540,540};
SDL_RenderCopy(renderer, rangeTexture_, &source, &destination );
}
else
{
SDL_Rect source={535,0,765,760};
SDL_Rect destination={heroLocation.fieldX-380, heroLocation.fieldY-380,760,765};
SDL_RenderCopy(renderer, rangeTexture_, &source, &destination );
}
}
void drawLights(){
int i;
setTexture(&config.map.tex[LIGHT]);
Color4f(1,1,1,1);
glEnable(GL_TEXTURE_2D);
// glPushMatrix();
// globalTransform();
for(i=0;i<config.map.tower_max;i++)
if (config.map.tower_array[i].id!=0)
if (checkGridLines(config.map.tower_array[i].position.x,config.map.tower_array[i].position.y)){
int owner=config.map.tower_array[i].owner;
float size=1; //if less -> more transparent; black -> transparent, bright -> black;
if (owner!=config.map.player_id)
size=(config.map.players[owner].group==config.map.player->group?0.7f:0.0f);
drawLight(&config.map.tower_array[i].position,1.5*size);
}
for(i=0;i<config.map.npc_max;i++)
if (config.map.npc_array[i].id!=0)
if (checkGridLines(config.map.npc_array[i].position.x,config.map.npc_array[i].position.y)){
int owner=config.map.npc_array[i].owner;
float size=1;
if (owner!=config.map.player_id)
size=(config.map.players[owner].group==config.map.player->group?0.7f:0.0f);
drawLight(&config.map.npc_array[i].position,1*size);
}
// glPopMatrix();
}
void HiRes5Engine::animateLights() const {
int index;
byte color = 0x2a;
for (index = 4; index >= 0; --index)
drawLight(index, color);
index = 4;
while (!g_engine->shouldQuit()) {
drawLight(index, color ^ 0x7f);
// There's a delay here in the original engine. We leave it out as
// we're already slower than the original without any delay.
const uint kLoopCycles = 25;
const byte period = (index + 1) << 4;
const double freq = kClock / 2.0 / (period * kLoopCycles);
const double len = 128 * period * kLoopCycles * 1000 / (double)kClock;
Tones tone;
tone.push_back(Tone(freq, len));
if (playTones(tone, false, true))
break;
drawLight(index, color ^ 0xff);
if (--index < 0) {
index = 4;
color ^= 0xff;
}
}
}
void content ()
{
glClear (GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
if (raycast)
{
DoRayTrace ();
DisplayImage ();
}
else
{
draw3Dscene();
glPushAttrib(GL_ENABLE_BIT);
drawLight();
if( track )
drawTrace();
hint();
glPopAttrib();
}
//
// FPS calculation and output
///////////////////////////////////////////////////////////
FPScomputation += 1;
glutSwapBuffers();
}
void drawScene(void)
{
drawAxes();
drawParameters();
drawLight();
currentTexture = textures[TEX_CRATE];
cube(0,0,0, 2,2,2, cubeRotation);
currentTexture = textures[TEX_DEFAULT];
}
// Rysuje samochód, zaczynaj¹c od œwiate³
void drawCar(glutil::MatrixStack &modelMatrix, glm::vec4 &lightPos) {
drawLight(modelMatrix, lightPos);
drawLight(modelMatrix, lightPos + glm::vec4(0.0, 0.0, nextLight, 0.0));
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(glm::vec3(carPosition) + glm::vec3(1.55f, 0.0, 0.75));
modelMatrix.Scale(3.0f, 0.8f, 2.1f);
glm::mat4 invTransform = glm::inverse(modelMatrix.Top());
glm::vec4 lightPosModelSpace = invTransform * lightPosCameraSpace;
glm::vec3 directionModelSpace = direction * glm::vec3(lightPosCameraSpace);
glUseProgram(adsShader.theProgram);
glUniformMatrix4fv(adsShader.modelToCameraMatrixUnif, 1, GL_FALSE,
glm::value_ptr(modelMatrix.Top()));
glUniform3fv(adsShader.position, 1, glm::value_ptr(lightPosModelSpace));
glUniform3f(adsShader.position2, lightPosModelSpace[0], lightPosModelSpace[1], lightPosModelSpace[2] + nextLight);
g_pCubeMesh->Render("color");
}
unsigned int refreshCutscene(void)
{
/* custom cutscene refresh - called within a loop */
/* update only this sprite and draw */
preDrawCycle();
if (state.draw != NULL)
state.draw();
if (state.light != NULL) {
drawLight();
}
postDrawCycle();
al_rest(0.006);
return true;
}
//
// Main drawing function. Renders a completed scene to the screen.
//
void Renderer::drawScene(Scene& scene, Camera& camera)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |
GL_STENCIL_BUFFER_BIT);
// Load the viewing translations.
resize(global.winWidth, global.winHeight);
glLoadMatrix(camera.getWorldToCamMatrix());
// Unlit scene + Depth Buffer info.
ambientPass(scene, camera);
// Only enter this loop if ambient only is not enabled.
if (!global.drawAmbientOnly)
{
// The rest of the rendering is done on a 'per-light' basis, shadows are
// determined for each light and the scene is additively illuminated.
for (int i = 0; i < scene.lights.size(); ++i)
{
if (i >= global.maxVisibleLights) break;
Light& light = scene.lights[i];
// Setup the light for drawing and draw it.
setupLight(light);
if (global.drawPointLights)
drawLight(light);
// Determine shadows and light the scene.
if (global.drawShadows)
{
determineShadows(scene.casters, light, camera);
}
// Iluminate the scene fro this light.
illuminationPass(scene, camera);
glClear(GL_STENCIL_BUFFER_BIT);
}
scene.dirtyAllCasters();
}
// Check for OpenGL errors.
int er = glGetError();
if (er) printf("%s\n", gluErrorString(er));
}
void drawScene(void)
{
if (renderMode == DEF_RENDER) {
drawAllAlxes();
drawGrid();
drawRelevantParameters();
drawBackground(3.5*dim);
drawLight();
drawBoard();
drawPath();
drawShots();
}
drawMinions();
drawObjects();
}
void ofApp::draw(){
ofBackgroundGradient( ofColor(40,40,40), ofColor(0,0,0), OF_GRADIENT_CIRCULAR);
ofEnableDepthTest();
scene.beginGBuffer(cam);
cam.begin();
drawGrid();
drawScene();
drawLight();
cam.end();
scene.endGBuffer();
ofDisableDepthTest();
scene.render();
// ofSetColor(ofColor::white);
// scene.drawGBuffer();
gui.draw();
}
/******************************************************************************
* Draw function called each frame
******************************************************************************/
void SampleViewer::draw()
{
// Clear default frame buffer
// glClearColor( 0.0f, 0.1f, 0.3f, 0.0f ); => already done by setBackgroundColor()
// glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); => already done in QGLViewr::preDraw() method
glEnable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
// Set light parameter
setLight( _light[ 3 ], _light[ 4 ] );
// Handle GigaVoxels draw
_sampleCore->draw();
// Draw the light
if ( _controlLight )
{
drawLight();
}
}
void Helper::paint(QPainter *painter, QPaintEvent *event, int elapsed, bool timerStopped)
{
painter->fillRect(event->rect(), background);
for (int i = 0; i < b->lights.length(); i++) {
glm::vec2 position = b->lights.at(i)->getPosition();
drawLight(painter, position.x, position.y, b->lights.at(i)->radius);
drawTrail(painter, b->lights.at(i)->trail, b->lights.at(i)->trailColor);
}
for (int j = 0; j < b->mosquitoes.length(); j++) {
if (!b->mosquitoes.at(j)->isEaten) {
drawMosquito(painter, b->mosquitoes.at(j)->position.x, b->mosquitoes.at(j)->position.y);
}
}
for (int k = 0; k < b->walls.length(); k++) {
drawWall(painter, b->walls.at(k)->point1.x, b->walls.at(k)->point1.y, b->walls.at(k)->point2.x, b->walls.at(k)->point2.y);
}
drawFrog(painter, b->frog->position.x, b->frog->position.y, b->frog->radius);
}
void
display(void)
{
int i;
GLfloat x, y, z;
LightBrightness ld[MAX_LIGHTS];
int start, end;
if (timeFrames) {
start = glutGet(GLUT_ELAPSED_TIME);
}
x = cos(t * 12.3) * 2.0;
y = 0.0;
z = sin(t) * 7.0;
for (i = 0; i < MAX_LIGHTS; i++) {
GLfloat dx, dy, dz;
GLfloat quadraticAttenuation;
/* Calculate object to light position vector. */
dx = (linfo[i].xyz[0] - x);
dy = (linfo[i].xyz[1] - y);
dz = (linfo[i].xyz[2] - z);
quadraticAttenuation = dx * dx + dy * dy + dz * dz;
if (brightnessModel == M_LAMBERTIAN) {
/* Lambertian surface-based brightness determination. */
GLfloat ex, ey, ez;
GLfloat nx, ny, nz;
GLfloat distance;
GLfloat diffuseReflection;
/* Determine eye point location (remember we can rotate by angle). */
ex = 16.0 * sin(angle * M_PI / 180.0);
ey = 1.0;
ez = 16.0 * -cos(angle * M_PI / 180.0);
/* Calculated normalized object to eye position direction (nx,ny,nz). */
nx = (ex - x);
ny = (ey - y);
nz = (ez - z);
distance = sqrt(nx * nx + ny * ny + nz * nz);
nx = nx / distance;
ny = ny / distance;
nz = nz / distance;
/* True distance needed, take square root. */
distance = sqrt(quadraticAttenuation);
/* Calculate normalized object to light postition direction (dx,dy,dz).
*/
dx = dx / distance;
dy = dy / distance;
dz = dz / distance;
/* Dot product of object->eye and object->light source directions.
OpenGL's lighting equations actually force the diffuse contribution
to be zero if the dot product is less than zero. For our purposes,
that's too strict since we are approximating the entire object with
a single object-to-eye normal. */
diffuseReflection = nx * dx + ny * dy + nz * dz;
if (attenuation == M_QUAD) {
/* Attenuate based on square of distance. */
ld[i].brightness = diffuseReflection / quadraticAttenuation;
} else {
/* Attenuate based on linear distance. */
ld[i].brightness = diffuseReflection / distance;
}
} else {
/* Distance-based brightness determination. */
/* In theory, we are really determining brightness based on just the
linear distance of the light source, but since we are just doing
comparisons, there is no reason to waste time doing a square root. */
/* Negation makes sure closer distances are "bigger" than further
distances for sorting. */
ld[i].brightness = -quadraticAttenuation;
}
ld[i].num = i;
}
/* Sort the lights so that the "brightest" are listed first. We really
want to just determine the first numActiveLights so a full sort is
overkill. */
qsort(ld, MAX_LIGHTS, sizeof(ld[0]), lightBrightnessCompare);
if (reportLightSignificance) {
printf("\n");
for (i = 0; i < MAX_LIGHTS; i++) {
printf("%d: dist = %g\n", ld[i].num, ld[i].brightness);
}
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(angle, 0.0, 1.0, 0.0);
glDisable(GL_LIGHTING);
for (i = 0; i < MAX_LIGHTS; i++) {
drawLight(&linfo[i]);
}
/* After sorting, the first numActiveLights (ie, <8) light sources are the
light sources with the biggest contribution to the object's lighting.
Assign these "virtual lights of significance" to OpenGL's actual
available light sources. */
glEnable(GL_LIGHTING);
for (i = 0; i < numActiveLights; i++) {
if (lightState[i]) {
int num = ld[i].num;
glLightfv(GL_LIGHT0 + i, GL_POSITION, linfo[num].xyz);
glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, linfo[num].rgb);
glEnable(GL_LIGHT0 + i);
} else {
glDisable(GL_LIGHT0 + i);
}
}
glPushMatrix();
glTranslatef(x, y, z);
switch (object) {
case M_SPHERE:
glCallList(DL_BIG_SPHERE);
break;
case M_ICO:
glCallList(DL_ICO);
break;
}
glPopMatrix();
if (labelLights) {
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
for (i = 0; i < numActiveLights; i++) {
labelLight(&linfo[ld[i].num], i);
}
glEnable(GL_DEPTH_TEST);
}
glPopMatrix();
if (timeFrames) {
glFinish();
end = glutGet(GLUT_ELAPSED_TIME);
printf("Speed %.3g frames/sec (%d ms)\n",
1000.0 / (end - start), end - start);
}
if (!singleBuffer) {
glutSwapBuffers();
}
}
void display(void)
{
//時間計測
static double time1, time2, drawTime, frame;
if(ang <= 0.001) time1 = timeGetTime();
//カラーバッファ,デプスバッファのクリア
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);
if(flagWireframe)//'w'でwireframeとsolid model切り替え
{
glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_POINT);
}
else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
setLight();
glUseProgram(shaderProg);
//描画
draw0(); draw1();
drawFloor(20.0, 20.0, 20, 20);
glUseProgram(0);
//影
drawShadow(0);//光源0に対する影
drawShadow(1);//光源1に対する影
//光源描画
drawLight();
drawSpotlight();
//回転角度更新
ang += dang;
if(ang >= 360.0)
{
time2 = timeGetTime();
//１回転当たりの描画時間
drawTime = (time2 - time1) * 0.001;
frame = (360.0 / dang) / drawTime;
printf("フレーム数 = %4.4f[fps] \n", frame);
//フレームあたりの描画時間
drawTime = 1.0 / frame;
printf("描画時間 = %4.4f[spf] \n", drawTime);
ang = 0.0;
}
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("[Page Up]キー：回転角度+0.1 \n");
printf("[Page Dn]キー：回転角度-0.1 \n");
printf("[F1]:光源の減衰モード切りかえ \n");
printf("[F2]キー:ｽﾎﾟｯﾄﾗｲﾄ指数調整 \n");
printf("[F3]キー:ｽﾎﾟｯﾄﾗｲﾄのｶｯﾄｵﾌ角度調整 \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
void display(void)
{
//時間計測
curTime = timeGetTime();
float dt = (float)(curTime - lastTime) * 0.001;//secに変換
elapseTime1 += dt;
elapseTime2 += dt;
fps ++;
printf("elapseTime2 = %f \n", elapseTime2);
if(elapseTime1 >= 1.0)
{
printf("frame per sec = %d \n", fps);
elapseTime1 = 0.0;
fps = 0;
}
lastTime = curTime;
//波データを作成し、投影マップを設定
if(kindWave == 0) makeWaveCircle(amp, elapseTime2);
else if(kindWave == 1) makeWavePlane(amp, elapseTime2);
else makeWaveMix(amp, elapseTime2);
makeTexImage();
setTexture();
if(flagWireframe)//'w'でwireframeとsolid model切り替え
{
glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_POINT);
}
else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
resize(width, height);
//カラーバッファのクリア
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
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);
//fragment shaderのユニフォーム変数インデックスを取得
GLint texLoc = glGetUniformLocation(shaderProg, "smplCaustics");
glUniform1i(texLoc, 0);//GL_TEXTURE0を適用
// シェーダプログラムの適用
glUseProgram(shaderProg);
//描画
fish1.motion1(elapseTime2);
fish2.motion1(elapseTime2);
drawFloor0(10.0, 10.0, 10, 10);
// シェーダプログラムの適用を解除
glUseProgram(0);
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_FALSE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧを書き込み禁止
glEnable(GL_BLEND);//ｱﾙﾌｧﾌﾞﾚﾝﾃﾞｨﾝｸﾞを有効にする
glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_SRC_ALPHA);//色混合係数を決める
//半透明描画
drawWave();
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_TRUE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧの書き込みを許可
glDisable(GL_BLEND);
//影
drawShadow();
drawLight();
if(flagHelp)
{
printf("矢印キーによる光源/投影中心移動 \n");
printf(" →,←：x軸 \n");
printf(" ↑,↓：y軸 \n");
printf(" [Shift]＋↑,↓：z軸 \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]キー：投影マッピングの視野角fovの増減 \n");
printf("[F2]キー：波の振幅amp \n");
printf("[F3]キー：波の種類（円形波と平面波）の切り替え \n");
printf("[F4]キー：円形波の個数切り替え \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
virtual void draw() { drawLight(); drawPlanet(); drawStar(); }
void display(void)
{
//時間計測
static double time1, time2, drawTime, frame;
if(ang <= 0.001) time1 = timeGetTime();
//ステップ1：デプスマップの作成
glClear(GL_DEPTH_BUFFER_BIT);// デプスバッファをクリアする
// ビューポートをテクスチャのサイズに設定する
glViewport(0, 0, SHD_WIDTH, SHD_HEIGHT);
// 透視変換行列を単位行列に設定する
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//光源位置を視点とするモデルビュー変換行列を設定
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluPerspective(fov, (float)SHD_WIDTH / (float)SHD_HEIGHT, 1.0, farZ);
gluLookAt(lightPos[0], lightPos[1], lightPos[2], 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
//設定したモデルビュー行列を保存しておく(setTextureMatrixで使用する)
glGetFloatv(GL_MODELVIEW_MATRIX, modelview);
//デプスバッファの内容だけを取得するので
//フレームバッファには書き込まない
glColorMask(0, 0, 0, 0);
//デプスバッファには背面の奥行きを記録する
glCullFace(GL_FRONT);
//デプスマップ作成のためにシーンを描画
draw0();
draw1();
drawGround();
// デプスバッファの内容をテクスチャメモリに転送
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, SHD_WIDTH, SHD_HEIGHT, 0);
//ステップ２
//通常の描画設定に戻す
resize(width, height);
glColorMask(1, 1, 1, 1); //フレームバッファへ書き込み許可
glCullFace(GL_BACK);//背面は描画しない
//カラーバッファのクリア
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();//視点を変えるときはこの位置に必要
if(cos(view.theta*M_PI/180.0) >= 0.0)// <= 90.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_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texName[0]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, texName[1]);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, texName[2]);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, texName[3]);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_2D, texName[4]);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D, texName[5]);
//描画
glUseProgram(shaderProg);
// シェーダプログラムの適用
glActiveTexture(GL_TEXTURE0);
GLint texLoc = glGetUniformLocation(shaderProg, "shadowMap");
glUniform1i(texLoc, 0);//GL_TEXTURE0を適用
GLint texColorLoc = glGetUniformLocation(shaderProg, "colorMap");
GLint texNormalLoc = glGetUniformLocation(shaderProg, "normalMap");
glUniform1i(texColorLoc, 1);//GL_TEXTURE1を適用
glUniform1i(texNormalLoc, 4);//GL_TEXTURE4を適用
draw0();
glUniform1i(texColorLoc, 2);//GL_TEXTURE2を適用
glUniform1i(texNormalLoc, 5);//GL_TEXTURE5を適用
draw1();
glUniform1i(texColorLoc, 3);//GL_TEXTURE3を適用
glUniform1i(texNormalLoc, 6);//GL_TEXTURE6を適用
drawGround();
// シェーダプログラムの適用を解除
glUseProgram(0);
drawLight();//光源の描画
//回転角度更新
ang += dang;
if(ang >= 360.0)
{
time2 = timeGetTime();
drawTime = (time2 - time1) * 0.001;
frame = (360.0 / dang) / drawTime;
printf("フレーム数 = %4.2f[fps] \n", frame);
//フレームあたりの描画時間
drawTime = 1.0 / frame;
printf("描画時間 = %4.5f[spf] \n", drawTime);
ang = 0.0;
}
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]キー：ｼｬﾄﾞｳﾏｯﾋﾟﾝｸﾞの視野角調整 \n");
printf("[F4]キー：ｼｬﾄﾞｳﾏｯﾋﾟﾝｸﾞの後方ｸﾘｯﾌﾟ面調整 \n");
printf("[Page Up]キー：回転角度+0.1 \n");
printf("[Page Dn]キー：回転角度-0.1 \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
void Native3Lesson::draw() {
// Set the OpenGL viewport to same size as the surface.
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Do a compile rotation every 10 seconds;
long time = GLUtils::currentTimeMillis() % 10000L;
float angleInDegrees = (360.0f / 10000.0f) * ((int) time);
// Set out pre-vertex lighting program.
glUseProgram(mPerVertexProgramHandle);
// Set program handle for cube drawing.
mMVPMatrixHandle = (GLuint) glGetUniformLocation(mPerVertexProgramHandle, "u_MVPMatrix");
mMVMatrixHandle = (GLuint) glGetUniformLocation(mPerVertexProgramHandle, "u_MVMatrix");
mLightPosHandle = (GLuint) glGetUniformLocation(mPerVertexProgramHandle, "u_LightPos");
mPositionHandle = (GLuint) glGetAttribLocation(mPerVertexProgramHandle, "a_Position");
mColorHandle = (GLuint) glGetAttribLocation(mPerVertexProgramHandle, "a_Color");
mNormalHandle = (GLuint) glGetAttribLocation(mPerVertexProgramHandle, "a_Normal");
// Calculate position of the light
// Rotate and then push into the distance.
mLightModelMatrix->identity();
mLightModelMatrix->translate(0, 0, -5);
mLightModelMatrix->rotate(angleInDegrees, 0, 1, 0);
mLightModelMatrix->translate(0, 0, 2);
Matrix::multiplyMV(mLightPosInWorldSpace, mLightModelMatrix->mData, mLightPosInModelSpace);
Matrix::multiplyMV(mLightPosInEyeSpace, mViewMatrix->mData, mLightPosInWorldSpace);
// right
mModelMatrix->identity();
mModelMatrix->translate(4.0f, 0.0f, -7.0f);
mModelMatrix->rotate(angleInDegrees, 1.0f, 0.0f, 0.0f);
drawCube();
// left
mModelMatrix->identity();
mModelMatrix->translate(-4.0f, 0.0f, -7.0f);
mModelMatrix->rotate(angleInDegrees, 0.0f, 1.0f, 0.0f);
drawCube();
// top
mModelMatrix->identity();
mModelMatrix->translate(0.0f, 4.0f, -7.0f);
mModelMatrix->rotate(angleInDegrees, 0.0f, 1.0f, 0.0f);
drawCube();
// bottom
mModelMatrix->identity();
mModelMatrix->translate(0.0f, -4.0f, -7.0f);
mModelMatrix->rotate(angleInDegrees, 0.0f, 1.0f, 0.0f);
drawCube();
// center
mModelMatrix->identity();
mModelMatrix->translate(0.0f, 0.0f, -5.0f);
mModelMatrix->rotate(angleInDegrees, 1.0f, 1.0f, 1.0f);
drawCube();
// Draw a pint to indicate the light
glUseProgram(mPointProgramHandle);
drawLight();
}
