【BumpMap】凹凸贴图绘制简单图形

最新推荐文章于 2023-02-16 20:25:46 发布
最新推荐文章于 2023-02-16 20:25:46 发布
阅读量2.1k 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lethelody/article/details/71915216
版权

BumpMap 的主要思想就是通过 (x + dx, y), (x - dx, y), (x, y + dy), (x, y - dy) 这四个点的高度计算出(x, y) 点法向量的改变量：

if (i != XMAX)
	normal[i][j] = normal[i][j] - (position[i][j] - position[i + 1][j]).Unitization() * (height[i][j] - height[i + 1][j]);
if (i != 0)
	normal[i][j] = normal[i][j] - (position[i][j] - position[i - 1][j]).Unitization() * (height[i][j] - height[i - 1][j]);

if (j != YMAX)
	normal[i][j] = normal[i][j] - (position[i][j] - position[i][j + 1]).Unitization() * (height[i][j] - height[i][j + 1]);
if (j != 0)
	normal[i][j] = normal[i][j] - (position[i][j] - position[i][j - 1]).Unitization() * (height[i][j] - height[i][j - 1]);

在实现过程中我们取 dx, dx 为相邻的格点就可以方便计算啦！其中 Unitization() 是单位化操作。


尝试理解一下第二行的运算，如果 (i + 1, j) 的高度要低于 (i, j)，显然 (i, j) 点的法向量应该偏向 (i + 1, j) 的方向。

(position[i][j] - position[i + 1][j]).Unitization()

是从 (i + 1, j) 指向 (i, j) 的单位向量，如果 
(height[i][j] - height[i + 1][j])
是一个正值，那么 
- (position[i][j] - position[i + 1][j]).Unitization() * (height[i][j] - height[i + 1][j])
就会沿着 (i, j) 到 (i + 1, j) 的方向，也就是normal应有的改变量。


还有一个小难点是建立球体的模型，我选择了使用三角片去贴满球体的表面，这里涉及到了球坐标到直角坐标的变换。

float theta = i * 2.0 * PI / XMAX, fai = j * PI / YMAX;

position[i][j].x = 1.0 * sin(fai) * sin(theta);
position[i][j].y = 1.0 * cos(fai);
position[i][j].z = 1.0 * sin(fai) * cos(theta);
而直角坐标的优点就是，(i, j) 的法线和 (i, j) 的坐标是一致的。 

	normal[i][j] = position[i][j];

剩下的就是用OpenGL绘制三角形和设置光照属性啦！就很简单~


附完整代码【当然可能有错咯】：

#include <GL/freeglut.h>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include "MyMath.h"

using namespace std;

const int XINIT = 800, YINIT = 800;

const int XMAX = 1600, YMAX = 800;

float height[XMAX + 1][YMAX + 1];

int XCURR = XINIT, YCURR = YINIT;

const int MY_POLYGON = 0, MY_SPHERE = 1;

const int MY_MODE = MY_SPHERE;

Vector3f position[XMAX + 1][YMAX + 1], normal[XMAX + 1][YMAX + 1];

void InitNormal() {
	for (int i = 0; i <= XMAX; i++)
		for (int j = 0; j <= YMAX; j++) {
			if (MY_MODE == MY_POLYGON) {
				normal[i][j].x = 0.0;
				normal[i][j].y = 0.0;
				normal[i][j].z = 1.0;
			}

			if (MY_MODE == MY_SPHERE) {
				normal[i][j] = position[i][j];
			}

			if (i != XMAX)
				normal[i][j] = normal[i][j] - (position[i][j] - position[i + 1][j]).Unitization() * (height[i][j] - height[i + 1][j]);
			if (i != 0)
				normal[i][j] = normal[i][j] - (position[i][j] - position[i - 1][j]).Unitization() * (height[i][j] - height[i - 1][j]);

			if (j != YMAX)
				normal[i][j] = normal[i][j] - (position[i][j] - position[i][j + 1]).Unitization() * (height[i][j] - height[i][j + 1]);
			if (j != 0)
				normal[i][j] = normal[i][j] - (position[i][j] - position[i][j - 1]).Unitization() * (height[i][j] - height[i][j - 1]);

			normal[i][j].Unitization();
		}
}

void RenderScene() {
	glClearColor(0.0, 0.0, 0.0, 1.0);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glPointSize(10.0f);
	glLineWidth(1.0f);

	glPushMatrix();

	{
		GLfloat sunLightPosition[] = {1.0f, 1.0f, 1.0f, 0.0f};
		GLfloat sunLightAmbient[] = {0.6f, 0.6f, 0.6f, 1.0f};
		GLfloat sunLightDiffuse[] = {0.6f, 0.6f, 0.6f, 1.0f};
		GLfloat sunLightSpecular[] = {1.0f, 1.0f, 1.0f, 1.0f};

		glLightfv(GL_LIGHT0, GL_POSITION, sunLightPosition);
		glLightfv(GL_LIGHT0, GL_AMBIENT, sunLightAmbient);
								   
		glLightfv(GL_LIGHT0, GL_DIFFUSE, sunLightDiffuse);
		glLightfv(GL_LIGHT0, GL_SPECULAR, sunLightSpecular);

		glEnable(GL_LIGHT0);
		glEnable(GL_LIGHTING);
	}
/*	
	static float rotateTheta = 0.0;

	glRotated(-23.5, 0.0, 0.0, 1.0);

	glRotated(rotateTheta, 0.0, 1.0, 0.0);

	rotateTheta += 1;
*/

	{
		GLfloat triangleMatAmbient[] = {0.6f, 0.6f, 0.6f, 1.0f};
		GLfloat triangleMatDiffuse[] = {0.6f, 0.6f, 0.6f, 1.0f};
		GLfloat triangleMatSpecular[] = {1.0f, 1.0f, 1.0f, 1.0f};
		GLfloat triangleMatEmission[] = {0.1f, 0.1f, 0.3f, 1.0f};
		GLfloat triangleMatShininess = 100.0f;

		glMaterialfv(GL_FRONT, GL_AMBIENT, triangleMatAmbient);
		glMaterialfv(GL_FRONT, GL_DIFFUSE, triangleMatDiffuse);
		glMaterialfv(GL_FRONT, GL_SPECULAR, triangleMatSpecular);
		glMaterialfv(GL_FRONT, GL_EMISSION, triangleMatEmission);
		glMaterialf(GL_FRONT, GL_SHININESS, triangleMatShininess);
	}

	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	glBegin(GL_TRIANGLES);

	{
		for (int i = 0; i < XMAX; i++)
			for (int j = 0; j < YMAX; j++) {
				glNormal3fv(normal[i][j]());
				glVertex3fv(position[i][j]());

				glNormal3fv(normal[i + 1][j]());
				glVertex3fv(position[i + 1][j]());

				glNormal3fv(normal[i][j + 1]());
				glVertex3fv(position[i][j + 1]());
			}

		for (int i = 0; i < XMAX; i++)
			for (int j = 0; j < YMAX; j++) {
				glNormal3fv(normal[i + 1][j]());
				glVertex3fv(position[i + 1][j]());

				glNormal3fv(normal[i + 1][j + 1]());
				glVertex3fv(position[i + 1][j + 1]());

				glNormal3fv(normal[i + 1][j + 1]());
				glVertex3fv(position[i][j + 1]());
			}
	}

	glEnd();

	glPopMatrix();

	glutSwapBuffers();
}

void ReshapeWindow(int w, int h) {
	glViewport(0, 0, w, h);

	XCURR = w;
	YCURR = h;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	gluPerspective(2 * atan(h / (YINIT * 5.0)) / PI * 180, 1.0 * w / h, 0.5, 18);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0f, 1.0f, 0.0);
}

void MouseMotion(int x, int y) {
	float xFloat = (x - XCURR * 0.5f) / (YINIT * 0.5);
	float yFloat = (YCURR * 0.5f - y) / (YINIT * 0.5);

	if (xFloat < -1.0 || xFloat > 1.0 || yFloat < -1.0 || yFloat > 1.0)
		return;

	int xInt = floor((xFloat + 1.0) * 0.5 * XMAX);
	int yInt = floor((yFloat + 1.0) * 0.5 * YMAX);

	height[xInt + 0][yInt + 0] = -3;
	height[xInt + 1][yInt + 0] = -3;
	height[xInt + 0][yInt + 1] = -3;
	height[xInt + 1][yInt + 1] = -3;
}

void MyInit() {
	for (int i = 0; i <= XMAX; i++)
		for (int j = 0; j <= YMAX; j++) {
			{
				if (i % 80 >= 20 && i % 80 < 60 && j % 80 >= 20 && j % 80 < 60)
					height[i][j] = 2.0;
				else
					height[i][j] = 0.0;
			}

			if (MY_MODE == MY_POLYGON) {
				position[i][j].x = i * 2.0 / XMAX - 1.0;
				position[i][j].y = j * 2.0 / YMAX - 1.0;
				position[i][j].z = 0.0;
			}


			if (MY_MODE == MY_SPHERE) {
				float theta = i * 2.0 * PI / XMAX, fai = j * PI / YMAX;

				position[i][j].x = 1.0 * sin(fai) * sin(theta);
				position[i][j].y = 1.0 * cos(fai);
				position[i][j].z = 1.0 * sin(fai) * cos(theta);
			}
		}
	
	InitNormal();
}

int main(int argc, char** argv) {
	glutInit(&argc, argv);

	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);

	glutInitWindowPosition(800, 40);

	glutInitWindowSize(XINIT, YINIT);

	glutCreateWindow("OpenGL");

	glEnable(GL_POINT_SMOOTH);

	glEnable(GL_LINE_SMOOTH);

	glEnable(GL_DEPTH_TEST);

	glutDisplayFunc(RenderScene);

	glutReshapeFunc(ReshapeWindow);

//	glutIdleFunc(RenderScene);

//	glutMotionFunc(MouseMotion);

	MyInit();

	glutMainLoop();
}

这个程序还有一些别的功能哦！


以下是用到的数据结构【其实只有一个】：

#pragma once
#include <math.h>
#include <iostream>

using namespace std;

const float PI = 3.1415926f;

class Vector3f {
public:
	float x, y, z, *array;

	Vector3f(float x = 0.0, float y = 0.0, float z = 0.0)
		: x(x), y(y), z(z) {
		array = new float[3];
	}

	Vector3f operator * (const float lambda) {
		return Vector3f(x * lambda, y * lambda, z * lambda);
	}

	Vector3f operator + (const Vector3f & tempVector3f) {
		return Vector3f(x + tempVector3f.x, y + tempVector3f.y,
			z + tempVector3f.z);
	}
	
	Vector3f operator - (const Vector3f & tempVector3f) {
		return Vector3f(x - tempVector3f.x, y - tempVector3f.y,
			z - tempVector3f.z);
	}

	Vector3f operator * (const Vector3f & tempVector3f) {
		return Vector3f(y * tempVector3f.z - z * tempVector3f.y,
			z * tempVector3f.x - x * tempVector3f.z,
			x * tempVector3f.y - y * tempVector3f.x);
	}

	Vector3f & operator = (const Vector3f & tempVector3f) {
		x = tempVector3f.x;
		y = tempVector3f.y;
		z = tempVector3f.z;

		return (*this);
	}

	~Vector3f() {
		delete[] array;
	}

	float Modulus() {
		return sqrt(x * x + y * y + z * z);
	}

	Vector3f & Unitization() {
		float modulus = Modulus();
		x /= modulus;
		y /= modulus;
		z /= modulus;

		return (*this);
	}

	float * operator () () {
		array[0] = x;
		array[1] = y;
		array[2] = z;
		return array;
	}

	friend ostream & operator << (ostream & out, const Vector3f & vec) {
		return out << vec.x << " " << vec.y << " " << vec.z;
	}
};

Lethelody
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UnityShader 浮雕凹凸贴图BumpMap与法线贴图NormalMap的原理及其区别
05-20
凹凸映射和纹理映射非常相似。然而，纹理映射是把颜色加到多边形上，而凹凸映射是把粗糙信息加到多边形上。
凹凸贴图(Bump Map)实现原理以及与法线贴图(Normal Map)的区别
weixin_30284355的博客
02-23 1960
凹凸贴图(Bump Map)实现原理 以及与法线贴图(Normal Map)的区别 1 前言 翻译这篇教程的目的是为了帮助那些对图形渲染技术有兴趣却又苦于找不到免费中文学习资料的人。在我的身边没有任何一位从事计算机专业的前辈，从刚学会 WINDOWS的基本操作到现在，我的计算机技术完全都是一步步自学过来的，算算学编程的历史也近5年时间了。我往往要花一半以上的学习时...
Bump Map
sunnytina的专栏
10-15 842
original link:http://freespace.virgin.net/hugo.elias/graphics/x_polybm.htm Bump mapping is very much like Texture Mapping. However, where Texture Mapping added colour toa polygon, Bump
bumpmap
Parfait的专栏
04-09 1321
Bump Map一般分2种：一种是Emboss Bump Map（浮雕凹凸贴图），它使用的是Height map，原理是在原始图像的基础上，对高度场图像进行复制、轻微平移、差操作。但它存在很多严重的局限性，它只能用于漫反射表面，对于镜面高光来说是不可能的。当光源直接照射在物体表面时，如果没有偏移，那么物体表面就不会出现任何凹凸现象。    另外一种是DOT3 Bump Map（点乘凹凸贴图），
bump map(凹凸贴图)的一个简单生成方法
xyx2999的专栏
12-08 794
bump map(凹凸贴图)的一个简单生成方法
ogl_dot3_bump_mapping.zip_bump_bump map_bump mapping_mapping
09-19
OpenGL中的Bump Mapping技术是一种通过模拟表面微小凹凸来增强纹理细节的视觉效果的方法。在3D图形渲染中，这种技术可以显著提升模型的视觉真实感，使其看起来更具质感和立体感。"ogl_dot3_bump_mapping.zip"这个...
Unity3D法线贴图和凹凸映射
最新发布
03-24
在Unity3D中，我们可以通过将高度贴图（Bump Map）传递给Shader，然后使用该信息来扭曲表面的法线，从而实现凹凸效果。 Shader在Unity3D中扮演着核心角色，它是控制物体如何显示的程序。通过编写自定义Shader，我们...
Bump_Mapping.rar_Bump_Mapping_OpenGl凹凸_bump_bump mapping_openGL
09-24
1. 凹凸贴图：首先，我们需要一个凹凸贴图（Bump Map），它是一个灰度图像，通常是从高度图转换而来的。灰度值代表了表面的相对高度，较暗的区域表示较低，较亮的区域表示较高。 2. 法线计算：在每个像素位置，我们...
HLSL凹凸贴图
01-08
在提供的“BumpMap”文件中，可能包含了实现凹凸贴图效果的HLSL源代码，包括顶点和像素着色器函数，以及相关的纹理加载和处理逻辑。开发者需要将这段代码集成到DirectX应用中，并确保所有依赖项正确配置，如纹理资源...
BumpMap、NormalMap的区别 （转）
GameRefer的专栏
08-19 2747
一种是Emboss Bump Map（浮雕凹凸贴图），它使用的是Height map，原理是在原始图像的基础上，对高度场图像进行复制、轻微平移、差操作。但它存在很多严重的局限性，它只能用于漫反射表面，对于镜面高光来说是不可能的。当光源直接照射在物体表面时，如果没有偏移，那么物体表面就不会出现任何凹凸现象。  DOT3 Bump Map（点乘凹凸贴图），它使用的是Normal Map，这是目前
芯片Bump map/Ball map是芯片封装的技术
热门推荐
cy413026的博客
03-26 2万+
Bump Mapping通过改变几何体表面各点的法线，使本来是平的东西看起来有凹凸的效果，是一种欺骗眼睛的技术.具体在封装工艺中 倒装芯片(Flip-chip IC）封装技术，不但能够满足芯片大量(High Pin-Count)与高密度(High-Density) I/O Pad的扇出（Fanout）要求，而且凸块（Bump）由于其优越的导电性能与热传导性能，为芯片-封装-系统的...
凹凸贴图（Bump Mapping）
vivo01的专栏
02-16 935
我们首先来看low-poly（多边形数较少）mesh和high-poly（多边形数量较多）mesh之间的不同。首先，最明显的不同就是high-poly能够表现出更多细节，但high-poly有比较大的性能开销。有没有一种比较折中的办法使得我们既能够让mesh看起来细节更加丰富，同时多边形数量尽可能少呢？这种方法就是bump mapping，使用了凹凸贴图，可以在多边形数量较少的情况下，也能表项出较多的表面细节，性能上根更具优势。在凹凸贴图中，有两种主要使用的贴图类型：法线贴图和高度贴图（视差贴图）。
凹凸映射（Bump Map）实现原理
可乐鸡翅
06-18 3440
James EBlinn在1978年提出了凹凸纹理映射技术的思想基础。这种方法并不是真正改变了物体表面的几何外观，而是在通过扰动物体表面的法向量来实现具有凹凸感的假象。 我翻译这篇教程的目的是为了帮助那些对图形渲染技术有兴趣却又苦于找不到免费中文学习资料的人。在我的身边没有任何一位从事计算机专业的前辈，从刚学会 WINDOWS的基本操作到现在，我的计算机技术完全都是一步步自学过来的，算算学编程的
Real-Time Rendering——6.7 Bump Mapping凹凸贴图
m0_37609239的博客
04-04 319
Real-Time Rendering——6.7 Bump Mapping凹凸贴图
几种凹凸贴图(Bump Mapping)的学习记录
syddf
07-12 2万+
凹凸贴图简介 凹凸贴图是纹理的一种应用，它主要用来实现类似砖块、墙体的那种凹凸不平的效果，相较于一般的纹理映射，它并不是通过纹理映射来改变材质本身的颜色，而是改变或扰动其法线的方向，而法线的方向被用在光线模型中，改变法线的方向就可以影响物体表面光照的明暗效果。因此，凹凸贴图实际上是一种欺骗式的手段，它并没有改变顶点的位置，让物体本身的模型变得凹凸不平，而是影响用户的视觉效果，让用户以为模型是凹凸...
BumpMap、NormalMap的区别
thenile的专栏
04-27 5896
BumpMap一种是Emboss Bump Map（浮雕凹凸贴图），它使用的是Height map，原理是在原始图像的基础上，对高度场图像进行复制、轻微平移、差操作。但它存在很多严重的局限性，它只能用于漫反射表面，对于镜面高光来说是不可能的。当光源直接照射在物体表面时，如果没有偏移，那么物体表面就不会出现任何凹凸现象。  DOT3 Bump Map（点乘凹凸贴图），它使用的是Normal
凹凸材质：从Bump Map 到 Relief Map
ronintao的专栏
08-22 4727
参考 1、Bump Mapping综述 2、Unity3D ShaderLab开发实战详解 写在前面         其实搞清了切线空间的问题之后，凹凸贴图这个论题就没有什么特别的难点了，因此这里只做简单的整理。 一、Bump Map         使用凹凸贴图，是为了给光滑的平面，在不增加顶点的情况下，增加一些凹凸的变化。他的原理是通过法向量的变化，来产生光影的变化
GIMP中文教程：阴影与凹凸贴图技巧
其次，教程介绍了“凹凸贴图(BumpMapping)”的制作。这一技术涉及到通道(channel)的应用和高斯模糊。在新建的白色背景图层上，使用油漆桶工具填充颜色，然后通过椭圆区域选择工具创建圆形选区。将选区保存到通道并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值