OpenGL 람 보 서 제7 장: 입체 하늘 과 무늬 굴절, 쌍 무늬 (하)

람 보 서 를 비교 해 보 니 홍 보 서 의 장점 을 알 수 있 었 다.
reflect 함수 의 원 리 는 홍 보 서 에 설명 되 어 있 습 니 다. 홍 보 서 를 비교 해 봐 야 홍 보 서 의 포 지 셔 닝: 고급 공구 서 를 알 수 있 습 니 다.
람 보 서 는 입문 급 서적 으로서 비교적 빠 른 속도 로 독자 로 하여 금 코드 를 두 드 려 생각 하 게 하고 탐색 해 야 할 내용 을 남 겼 다.
람 보 서 는 다 읽 어야 한다.
홍 보 서 다 봐 야 돼.
C + + 11 표준 판 영문 판도 작은 부분 을 봤 다.
다 중 스 레 드 입문 도 아니 야.
Socket 은 기초 네트워크 연결 만 실현 할 수 있 고 진정한 데이터 통신 과 는 거리 가 멀다. 하물며 여러 명의 온라인 대전 네트워크 모델 의 실현
디자인 모드 를 보고 또 잊 고 또 보고, 모듈 등급 의 코드 를 디자인 할 기회 가 없다 면 정말 피 가 나 서 소 용 없어 요. UI 를 바 꿀 까요?야근 해서 일 하 는 게 무슨 박력 이 야?안 타 깝 게 도 그 당시 에 수요 의 진 화 를 예산 하지 못 했 기 때문에 나 는 전략 모델 이나 장식 자 모델 로 코드 구 조 를 조정 해 야 했다.
공장 모드: 클래스 대상 의 생 성 과정 을 밀봉 하여 서로 다른 매개 변 수 를 사용 하지 않 는 대상 을 가 져 올 수 있 도록 합 니 다.
단일 모드: 제어 모듈 간 데이터 액세스 출구, 모듈 간 결합 감소
전략 모드: 데 이 터 를 사용 하지 않 고 통 일 된 행 위 를 보 여 주 며 단일 사례 와 유사 한 용법 을 제공 하여 결합 을 낮 출 수 있 습 니 다.
그 당시 에 UI 를 쓸 마음 이 없 었 습 니 다. 대부분의 시간 을 기능 과 AI 를 실현 하 는 데 사 용 했 습 니 다. UI 의 수요 가 저 를 눌 러 죽 이 는 마지막 지푸라기 가 될 줄 누가 알 았 겠 습 니까? 주관 들 이 보 여줄 수 있 는 UI 가 가장 높 은 우선권 을 가진다 고 입 을 모 았 거나 그 당시 의 메 인 과정 은 제 가 UI 의 크 고 작은 수 요 를 온전 하 게 실현 하고 보 이 는 것 을 저 에 게 주 기 를 바 랐 기 때 문 입 니 다. 하지만...새 코드 는 나 로 하여 금 한꺼번에 3 대 모듈 을 접 하 게 하 는데, 나 는 하필 이면 UI 를 가장 좋아 하지 않 는 다.게다가 내부 에 이상 한 움직임 이 있어 서 저 는 적당 한 쟁취 가 없 었 고 메 인 코스 는 UI 임 무 를 추 가 했 습 니 다.그래, 사 랑스 럽 지 않 은 결말, UI 한 무더기 가 해 줄 게. 어떻게 발전 하 는 지 볼 까?
적어도 나 는 오늘 도형 렌 더 링 의 입문 을 해결 하고 수요 에 직면 하여 프로그램 에 대한 변경 은 기 존의 코드 를 변경 하 는 것 이 아니 라 새로운 코드 를 추가 하 는 것 임 을 깨 달 았 다.
의사 소통 에서 의식 적 으로 무시 당 하 는 것 보다 변화 성 을 의식 해 야 한다.
무의미 한 잔업 은 이런 진보 가 있 을 수 없다.비록 내 가 간 후에 너희들 의 상금 이 많아 졌 지만, 메 인 코스 는 나의 선임 자 와 나 를 가게 할 수 있 고, 너희들 은 그 후에 다른 우수한 팀 원 들 을 보 낼 수 있 을 것 이다.
내 가 선택 한 이 길 은 힘 들 지만 가 벼 워 보 이 며 견 디 기만 하면 큰 신 이 될 수 있다.
win 32 또는 다른 운영 체제 파일 헤더 의 시간 스탬프 를 아직 찾 지 못 했 습 니 다. 같은 파일 사본 의 MD5 정확 한 검 사 를 어떻게 실현 합 니까?만약 에 찾 았 다 고 가정 하면 파일 업데이트 목록 의 가감 은 로 컬 목록 을 만 들 고 업데이트 목록 을 가 져 오 는 비교 차 이 를 얻 을 수 있 습 니 다. 다운로드 모듈 을 호출 하여 로 컬 자원 경로 에 덮어 쓰 거나 채 울 수 있 습 니 다.
네 비게 이 션 그리드 내용 에서 삼각형 생 성 원 리 를 이해 하지 못 했 습 니 다. 남 의 박사 논문 은 한 달 안에 알 아 보고 싶 습 니 다. 타당 성 이 낮 습 니 다.
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 
#include 
#include 
#include 
#include 

#ifdef __APPLE__
#include 
#else
#define FREEGLUT_STATIC
#include 
#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
", glewGetErrorString(err));
		return 1;
	}


	SetupRC();

	glutMainLoop();

	ShutdownRC();

	return 0;
}