OpenGL蓝宝书第七章：立体天空和纹理折射、双纹理（下）

对比了蓝宝书，才知道红宝书的优点。

reflect函数的原理在红宝书中有说明，只有对比了红宝书，才知道红宝书的定位：高级工具书。

蓝宝书作为入门级书籍，以较快的速度让读者敲到代码去思考，总遗留了需要探索的内容。

蓝宝书要看完。

红宝书要看完。

C++11 标准版英文版也看了小部分。

多线程入门都不算。

Socket只能实现基础网络连接，离真正的数据通信都算，何况多人在线对战网络模型的实现

设计模式看了又忘了，忘了又看，如果没有机会去设计模块级别的代码实现，真的血了没用，难道改UI？加班赶工哪有魄力稍微幅度大点调整代码。可惜当时没预算到需求的演化需要我去用策略模式或者装饰者模式去调整代码结构。

工厂模式：封装了类对象的生成过程，允许不同参数获取不用对象

单例模式：控制模块间的数据访问出口，减低模块之间的耦合

策略模式：也可以封装不用数据表现出统一的行为，提供了类似于单例的用法，减低耦合。

当时无心写UI，大部分时间用来实现技能和AI，谁知UI的需求演化成为压死我的最后一根稻草——因为主管们一致认为可展示的UI具有最高的优先权，或者说当时主程只希望我能完整实现UI的大大小小需求，给一个看得到的东西给我，可是，新代码一次性让我接触到3大模块，我最不喜欢偏偏是UI。加上内部一些异动，我没有适当地争取，主程又给我增加UI任务。对啊，不讨人喜欢的下场，一堆UI给你做，看你怎么进步？

至少我今天搞定了图形渲染的入门，明白了面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。

要意识到变化性往往比沟通中被有意识忽略的多多了。

无意义的加班是不可能有这些进步的。虽然我走了之后你们的奖金池多了，但是主程能让人我的前任和我走了，你们之后就能让其他优秀队友走。

我选的这条路虽然辛苦，看着轻浮，只要熬过了之后我就能成为大神。

win32或其他操作系统文件头中的时间戳还没找到，怎么实现同文件副本的MD5正确校验？假设找到了，文件更新列表的加减可以由生成本地列表和获取更新列表对比差异得到，调用下载模块，覆盖或者填充在本地资源路径下。

导航网格内容中，至今没能理解三角形生成原理，人家的博士论文，想在1个月内看懂，可行性很低啊

ORGE没碰、Unreal Engine 4.0 啃不下、Cocos 3D、Gameplay3D，如何深化？

至于IK，还很远，数学、物理基础知识都要补呢。

//vp

#version 330

in vec4 vVertex;
in vec3 vNormal;
in vec2 vTexCoords;

uniform mat4 mvpMatrix;
uniform mat4 mvMatrix;
uniform mat3 normalMatrix;
uniform mat4 mInverseCamera;

smooth out vec3 vVaryingTexCoord;
smooth out vec2 vTarnishCoords;

void main(void)
{
//在惯性系的坐标
vec3 vEyeNormal = normalMatrix * vNormal;

vec4 vPosition4 = mvMatrix * vVertex;
vec3 vEyeVertex = normalize(vPosition4.xyz/vPosition4.w);

vec4 cCoords = vec4(reflect(vEyeVertex,vEyeNormal),1.0f);//不清楚reflect的原理，导致代码思想断片，靠猜？开玩笑，还是开源比较好
cCoords = mInverseCamera * cCoords;//全面反射场景？？？

vVaryingTexCoord.xyz = normalize(cCoords.xyz); //获得是什么坐标？

vTarnishCoords = vTexCoords.st;

gl_Position = mvpMatrix * vVertex;
}

//fp

#version 330

smooth in vec3 vVaryingTexCoord;
smooth in vec2 vTarnishCoords;

uniform samplerCube cubeMap;
uniform sampler2D tarnishMap;

out vec4 vFragColor;

void main(void)
{
vFragColor = texture(cubeMap, vVaryingTexCoord.stp);
//两段纹理，只需要颜色相乘就可以了。后面的纹理为最外层色彩
vFragColor *= texture(tarnishMap, vTarnishCoords.st);
}

//cpp

#include <GLTools.h>
#include <GLMatrixStack.h>
#include <GLFrame.h>
#include <GLFrustum.h>
#include <GLGeometryTransform.h>

#ifdef __APPLE__
#include <glut/glut.h>
#else
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

GLFrame viewFrame;
GLFrustum viewFrustum;
GLMatrixStack projctionMatrix;
GLMatrixStack mvpMatrix;
GLMatrixStack modelViewMatrix;
GLGeometryTransform transformPipeLine;

GLTriangleBatch sphereBatch;
GLBatch cubeBatch;

GLuint tarnishTexture;
GLuint cubeTexture;
GLuint reflectionShader;
GLuint skyBoxShader;

GLint locMVPReflect;
GLint locMVReflect;
GLint locNormalReflect;
GLint locInvertedCamera;

GLint locCubeMap, locTarnishMap;

GLint locMVPSkyBox;

// Six sides of a cube map
const char *szCubeFaces[6] = { "pos_x.tga", "neg_x.tga", "pos_y.tga", "neg_y.tga", "pos_z.tga", "neg_z.tga" };

GLenum cube[6] = {
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
};

void ChangeSize(int w, int h)
{
if (h <= 0)
{
h = 1;
}

glViewport(0, 0, w, h);
viewFrustum.SetPerspective(80.0f, float(w) / float(h), 1.0f, 120.0f);
projctionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
transformPipeLine.SetMatrixStacks(modelViewMatrix, projctionMatrix);
}

void SetupRC(void)
{
GLbyte * pBytes;
int nWidth, nHeight, nComponent;
GLenum eFormat;

glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

// Load the tarnish texture
glGenTextures(1, &tarnishTexture);
glBindTexture(GL_TEXTURE_2D, tarnishTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

pBytes = gltReadTGABits("tarnish.tga", &nWidth, &nHeight, &nComponent, &eFormat);
glTexImage2D(GL_TEXTURE_2D, 0, nComponent, nWidth, nHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);
free(pBytes);
glGenerateMipmap(GL_TEXTURE_2D);

glGenTextures(1, &cubeTexture);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);

glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

for (size_t i = 0; i < 6; ++i)
{
pBytes = gltReadTGABits(szCubeFaces[i], &nWidth, &nHeight, &nComponent, &eFormat);
// border 为0，是指边框的宽度
//eFormat 不需要 和internalFormat取值必须相同，都是指定纹理中的颜色组件
glTexImage2D(cube[i], 0, nComponent, nWidth, nHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);
free(pBytes);
}
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);

viewFrame.MoveForward(-4.0f);
gltMakeSphere(sphereBatch, 1.0f, 52, 26);
gltMakeCube(cubeBatch, 20.0f);

reflectionShader = gltLoadShaderPairWithAttributes("Reflection.vp", "Reflection.fp", 3,
GLT_ATTRIBUTE_VERTEX, "vVertex",
GLT_ATTRIBUTE_NORMAL, "vNormal",
GLT_ATTRIBUTE_TEXTURE0, "vTexCoords");
//uniform值绑定
locMVPReflect = glGetUniformLocation(reflectionShader, "mvpMatrix");
locMVReflect = glGetUniformLocation(reflectionShader, "mvMatrix");
locNormalReflect = glGetUniformLocation(reflectionShader, "normalMatrix");
locInvertedCamera = glGetUniformLocation(reflectionShader, "mInverseCamera");

locCubeMap = glGetUniformLocation(reflectionShader, "cubeMap");
locTarnishMap = glGetUniformLocation(reflectionShader, "tarnishMap");

skyBoxShader = gltLoadShaderPairWithAttributes("skyBox.vp", "skyBox.fp", 1, GLT_ATTRIBUTE_VERTEX, "vVertex");
//uniform值绑定

locMVPSkyBox = glGetUniformLocation(skyBoxShader, "mvpMatrix");

//启用两段纹理 与顶点着色器输入输出的纹理数组对应
// glUniform1i(locCubeMap, 0);
// glUniform1i(locTarnishMap, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, tarnishTexture);

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeTexture);
}

void RenderScene(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

M3DMatrix44f mCamera;
M3DMatrix44f mCameraRotOnly;
M3DMatrix44f mInverseCamera;

viewFrame.GetCameraMatrix(mCamera, false);
viewFrame.GetCameraMatrix(mCameraRotOnly, true);
m3dInvertMatrix44(mInverseCamera, mCameraRotOnly);

modelViewMatrix.PushMatrix();
{

modelViewMatrix.MultMatrix(mCamera);//向后移动 4.0f，惯性坐标系的向后则是z变小，模型变小
glUseProgram(reflectionShader);

glUniformMatrix4fv(locMVReflect, 1, GL_FALSE, transformPipeLine.GetModelViewMatrix());
glUniformMatrix4fv(locMVPReflect, 1, GL_FALSE, transformPipeLine.GetModelViewProjectionMatrix());
glUniformMatrix3fv(locNormalReflect, 1, GL_FALSE, transformPipeLine.GetNormalMatrix());
glUniformMatrix4fv(locInvertedCamera, 1, GL_FALSE, mInverseCamera);

glUniform1i(locCubeMap, 0);
glUniform1i(locTarnishMap, 1);

glEnable(GL_CULL_FACE);
sphereBatch.Draw();
glDisable(GL_CULL_FACE);
}
modelViewMatrix.PopMatrix();

modelViewMatrix.PushMatrix();
{
modelViewMatrix.MultMatrix(mCameraRotOnly);
glUseProgram(skyBoxShader);
glUniformMatrix4fv(locMVPSkyBox, 1, GL_FALSE, transformPipeLine.GetModelViewProjectionMatrix());
cubeBatch.Draw();
}
modelViewMatrix.PopMatrix();

glutSwapBuffers();
}

void SpecialKeys(int key, int x, int y)
{
float linear = 1.0f;
float angular = float(m3dDegToRad(5.0f));

if (key == GLUT_KEY_UP)
viewFrame.MoveForward(linear);

if (key == GLUT_KEY_DOWN)
viewFrame.MoveForward(-linear);

if (key == GLUT_KEY_LEFT)
viewFrame.RotateWorld(angular, 0.0f, 1.0f, 0.0f);

if (key == GLUT_KEY_RIGHT)
viewFrame.RotateWorld(-angular, 0.0f, 1.0f, 0.0f);

glutPostRedisplay();
}

void ShutdownRC(void)
{
glDeleteTextures(1, &tarnishTexture);
glDeleteTextures(1, &cubeTexture);
glDeleteProgram(reflectionShader);
glDeleteProgram(skyBoxShader);
}

int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("OpenGL Cube Maps");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
glutSpecialFunc(SpecialKeys);

GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
return 1;
}

SetupRC();

glutMainLoop();

ShutdownRC();

return 0;
}