Java软光栅渲染器-光照、材质与着色器

目标

为实现顶点光照着色做准备,本章将要定义一些新东西。

  • 定义光源
  • 定义材质
  • 定义着色器接口
  • 实现着色器

实现

我越来越兴奋了。

定义光源

一般来说,3D图形引擎应该支持4种光源,分别是:

  • 环境光
  • 定向光(平行光)
  • 点光源
  • 聚光灯

我打算先创建光源的抽象类,然后再慢慢实现每一种光源。

Light

新建一个net.jmecn.light包,定义四种光源的父类。

Light类只有颜色属性,没有其它参数。

默认颜色为白色。

package net.jmecn.light;

import net.jmecn.math.Vector4f;

/**
 * 光源
 * @author yanmaoyuan
 *
 */
public abstract class Light {

    // 光源的颜色
    protected Vector4f color;

    public Light() {
        color = new Vector4f(1, 1, 1, 1);
    }

    public Light(Vector4f color) {
        this.color = color;
    }

    public Vector4f getColor() {
        return color;
    }

    public void setColor(Vector4f color) {
        this.color = color;
    }

}

AmbientLight

环境光跟父类基本上没区别。

package net.jmecn.light;

import net.jmecn.math.Vector4f;

/**
 * 环境光
 * @author yanmaoyuan
 *
 */
public class AmbientLight extends Light {

    public AmbientLight() {
        super();
    }

    public AmbientLight(Vector4f color) {
        super(color);
    }

}

DirectionalLight

定向光,或者说平行光,多了一个方向属性。

package net.jmecn.light;

import net.jmecn.math.Vector3f;
import net.jmecn.math.Vector4f;

/**
 * 定向光源(平行光)
 * @author yanmaoyuan
 *
 */
public class DirectionalLight extends Light{

    // 光照方向
    protected Vector3f direction;

    public DirectionalLight(Vector3f direction) {
        super();
        this.direction = direction;
    }

    public DirectionalLight(Vector4f color) {
        super(color);
        this.direction = new Vector3f(0, 0, -1);
    }

    public DirectionalLight(Vector4f color, Vector3f direction) {
        super(color);
        this.direction = direction;
    }

    public Vector3f getDirection() {
        return direction;
    }

    public void setDirection(Vector3f direction) {
        this.direction = direction;
    }

}

管理光源

光源将用于渲染三维场景。在Renderer中添加一个 List<Light> lights 成员,并提供set方法。

// 光源
private List<Light> lights;

/**
 * 设置光源
 * @param lights
 */
public void setLights(List<Light> lights) {
    this.lights = lights;
}

在 Application 中也添加一个 List<Light> lights 成员,用于管理场景中的光源。这个成员是protected权限的,Application的子类可以直接通过lights.add(..)方法来添加光源。

// 光源
protected List<Light> lights;

/**
 * 构造方法
 */
public Application() {
    // ..

    // 光源
    lights = new ArrayList<Light>();

    // ..
}

一般来说,光源需要在应用程序的主循环中更新,然后在每次调用renderer.render()方法之前设置给Renderer。不过我现在用的是Java语言,可以直接让Renderer和Application共用同一个对象的引用。

直接在Application的start方法中,把lights的引用传给Renderer即可。

/**
 * 启动程序
 */
public void start() {
    // 计时器..

    // 创建主窗口..

    // 创建渲染器
    renderer = new Renderer(width, height);
    renderer.setBackgroundColor(ColorRGBA.DARKGRAY);
    renderer.setLights(lights);// <----

    // ..

    // 初始化
    initialize();

    while (isRunning) {
        // ..

    }

    // ..
}

定义材质

目前Material类中只有一个Texture和一个RenderState,还远不能用来描述模型的外观。给Material增加各种参数,这样在着色阶段才能够正常使用。

如果你不太理解这些参数的作用,可以查阅这篇文章:http://blog.jmecn.net/3d-game-terminology/

Material的代码如下:

/**
 * 材质
 * 
 * @author yanmaoyuan
 *
 */
public class Material {

    protected RenderState renderState;

    private boolean isUseVertexColor;   // 是否使用顶点色

    private Vector4f emssive;           // 自发光色
    private Vector4f diffuse;           // 漫反射光色
    private Vector4f ambient;           // 环境光色
    private Vector4f specular;          // 高光颜色
    private float shininess;            // 光泽度

    private Texture emssiveMap;         // 发光贴图
    private Texture diffuseMap;         // 漫反射贴图
    private Texture specularMap;        // 高光贴图

    private Texture normalMap;          // 法线贴图

    public Material() {
        // 初始化渲染状态
        renderState = new RenderState();

        // 初始化材质参数
        isUseVertexColor = false;   // 不使用顶点色
        emssive = new Vector4f(0);  // 黑色
        diffuse = new Vector4f(1);  // 白色
        ambient = new Vector4f(1);  // 白色
        specular = new Vector4f(0); // 黑色
        shininess = 1f;             // 不光泽

        emssiveMap = null;
        diffuseMap = null;
        specularMap = null;
        normalMap = null;
    }
}

然后,为Material增加一些getter和setter。

public boolean isUseVertexColor() {
    return isUseVertexColor;
}

public void setUseVertexColor(boolean isUseVertexColor) {
    this.isUseVertexColor = isUseVertexColor;
}

public Vector4f getEmssive() {
    return emssive;
}

public void setEmssive(Vector4f emssive) {
    this.emssive.set(emssive);
}

public Vector4f getDiffuse() {
    return diffuse;
}

public void setDiffuse(Vector4f diffuse) {
    this.diffuse.set(diffuse);
}

public Vector4f getAmbient() {
    return ambient;
}

public void setAmbient(Vector4f ambient) {
    this.ambient.set(ambient);
}

public Vector4f getSpecular() {
    return specular;
}

public void setSpecular(Vector4f specular) {
    this.specular.set(specular);
}

public float getShininess() {
    return shininess;
}

public void setShininess(float shininess) {
    this.shininess = shininess;
}

public Texture getDiffuseMap() {
    return diffuseMap;
}

public void setDiffuseMap(Texture diffuseMap) {
    this.diffuseMap = diffuseMap;
}

public Texture getSpecularMap() {
    return specularMap;
}

public void setSpecularMap(Texture specularMap) {
    this.specularMap = specularMap;
}

public Texture getEmssiveMap() {
    return emssiveMap;
}

public void setEmssiveMap(Texture emssiveMap) {
    this.emssiveMap = emssiveMap;
}

public Texture getNormalMap() {
    return normalMap;
}

public void setNormalMap(Texture normalMap) {
    this.normalMap = normalMap;
}

注意,Material中原来的texture成员被我删掉了,用diffuseMap来取代。在与Texture有关的几个测试用例中,都要把setTexture方法改成setDiffuseMap。

定义着色器

用Java来实现着色器?听起来挺疯狂的。

创建一个Shader抽象类,主要包含顶点着色和片段着色两个接口,用来取代渲染管线中的vertexShader方法和fragmentShader方法。

package net.jmecn.shader;

import net.jmecn.scene.RasterizationVertex;
import net.jmecn.scene.Vertex;

/**
 * 着色器
 * @author yanmaoyuan
 *
 */
public abstract class Shader {

    /**
     * 顶点着色器
     * @param vertex
     * @return
     */
    public abstract RasterizationVertex vertexShader(Vertex vertex);

    /**
     * 片段着色器
     * @param frag
     */
    public abstract boolean fragmentShader(RasterizationVertex frag);

}

Uniform

着色器在工作时需要各种uniform变量(主要是变换矩阵),把各种空间变换矩阵都定义成Shader的protected成员,这样Shader的实现类就可以直接访问它们了。

// uniforms
protected Matrix4f worldMatrix;
protected Matrix4f viewMatrix;
protected Matrix4f projectionMatrix;
protected Matrix4f viewProjectionMatrix;
protected Matrix4f worldViewMatrix;
protected Matrix4f worldViewProjectionMatrix;

// getter/setters
public Matrix4f getWorldMatrix() {
    return worldMatrix;
}

public void setWorldMatrix(Matrix4f worldMatrix) {
    this.worldMatrix = worldMatrix;
}

public Matrix4f getViewMatrix() {
    return viewMatrix;
}

public void setViewMatrix(Matrix4f viewMatrix) {
    this.viewMatrix = viewMatrix;
}

public Matrix4f getProjectionMatrix() {
    return projectionMatrix;
}

public void setProjectionMatrix(Matrix4f projectionMatrix) {
    this.projectionMatrix = projectionMatrix;
}

public Matrix4f getViewProjectionMatrix() {
    return viewProjectionMatrix;
}

public void setViewProjectionMatrix(Matrix4f viewProjectionMatrix) {
    this.viewProjectionMatrix = viewProjectionMatrix;
}

public Matrix4f getWorldViewMatrix() {
    return worldViewMatrix;
}

public void setWorldViewMatrix(Matrix4f worldViewMatrix) {
    this.worldViewMatrix = worldViewMatrix;
}

public Matrix4f getWorldViewProjectionMatrix() {
    return worldViewProjectionMatrix;
}

public void setWorldViewProjectionMatrix(Matrix4f worldViewProjectionMatrix) {
    this.worldViewProjectionMatrix = worldViewProjectionMatrix;
}

这些Uniform变量未必够用。比如计算法线时可能需要用WorldMaterix的逆矩阵的转置矩阵(简称WorldMatrix_IT,或者NormalMatrix)。需要但未定义的Uniform可以留到以后再来处理,现在先把Shader系统设计出来。

Attributes

Attribute属性是着色时使用的变量,由应用程序传给Shader。不过既然我用的是Java,大可不必专门维持一个Attributes列表,可以用简单点的办法。

// attributes
protected Material material;
protected List<Light> lights;

public Material getMaterial() {
    return material;
}

public void setMaterial(Material material) {
    this.material = material;
}

public List<Light> getLights() {
    return lights;
}

public void setLights(List<Light> lights) {
    this.lights = lights;
}

如你所见,我把材质和光源直接定义成了Shader的Attribute属性,只要在使用shader之前先把material和lights设置给它就好了。如果需要其他的Attribute,还可以继续扩展。

毕竟是Java,不像GLSL有那么多的限制。

默认着色器实现

创建一个DefaultShader类,实现目前Renderer类和SoftwareRaster类中的着色功能。

package net.jmecn.shader;

import net.jmecn.material.Texture;
import net.jmecn.math.Vector4f;
import net.jmecn.scene.RasterizationVertex;
import net.jmecn.scene.Vertex;

/**
 * 默认着色器
 * @author yanmaoyuan
 *
 */
public class DefaultShader extends Shader {

    @Override
    public RasterizationVertex vertexShader(Vertex vertex) {
        RasterizationVertex out = new RasterizationVertex();
        // 顶点位置
        out.position.set(vertex.position, 1f);
        // 顶点法线
        if (vertex.normal != null) {
            out.normal.set(vertex.normal);
            out.hasNormal = true;
        }
        // 纹理坐标
        if (vertex.texCoord != null) {
            out.texCoord.set(vertex.texCoord);
            out.hasTexCoord = true;
        }
        // 顶点颜色
        if (vertex.color != null) {
            out.color.set(vertex.color);
            out.hasVertexColor = true;
        }

        // 模型-观察-透视 变换
        worldViewProjectionMatrix.mult(out.position, out.position);

        return out;
    }

    @Override
    public boolean fragmentShader(RasterizationVertex frag) {
        Texture texture = material.getDiffuseMap();
        if (texture != null && frag.hasTexCoord) {
            Vector4f texColor = texture.sample2d(frag.texCoord);
            frag.color.multLocal(texColor);
        }

        return true;
    }

}

vertexShader的实现有一点臃肿,这个方法中很大的篇幅是在复制Vertex对象的值,未来实现其他Shader算法时都会用到。不如把它提取出来做成一个方法,写在Shader抽象类中,这样之类就可以直接调用了。

/**
 * 复制顶点数据
 * @param vertex
 * @return
 */
protected RasterizationVertex copy(Vertex vertex) {
    RasterizationVertex out = new RasterizationVertex();
    // 顶点位置
    out.position.set(vertex.position, 1f);
    // 顶点法线
    if (vertex.normal != null) {
        out.normal.set(vertex.normal);
        out.hasNormal = true;
    }
    // 纹理坐标
    if (vertex.texCoord != null) {
        out.texCoord.set(vertex.texCoord);
        out.hasTexCoord = true;
    }
    // 顶点颜色
    if (vertex.color != null) {
        out.color.set(vertex.color);
        out.hasVertexColor = true;
    }

    return out;
}

这样的话,DefaultShader中的代码就可以简化了。

package net.jmecn.shader;

import net.jmecn.material.Texture;
import net.jmecn.math.Vector4f;
import net.jmecn.scene.RasterizationVertex;
import net.jmecn.scene.Vertex;

/**
 * 默认着色器
 * @author yanmaoyuan
 *
 */
public class DefaultShader extends Shader {

    @Override
    public RasterizationVertex vertexShader(Vertex vertex) {
        RasterizationVertex out = copy(vertex);

        // 模型-观察-透视 变换
        worldViewProjectionMatrix.mult(out.position, out.position);

        return out;
    }

    @Override
    public boolean fragmentShader(RasterizationVertex frag) {
        Texture texture = material.getDiffuseMap();
        if (texture != null && frag.hasTexCoord) {
            Vector4f texColor = texture.sample2d(frag.texCoord);
            frag.color.multLocal(texColor);
        }

        return true;
    }

}

在材质中增加着色器

在Material类中增加一个Shader成员,默认使用DefaultShader。

在设置Shader时把Material对象的引用传给shader,这样在shader中就可以访问这个Material中的属性了。

package net.jmecn.material;

import net.jmecn.math.Vector4f;
import net.jmecn.shader.DefaultShader;
import net.jmecn.shader.Shader;

/**
 * 材质
 * 
 * @author yanmaoyuan
 *
 */
public class Material {

    // ..

    // 着色器
    private Shader shader;

    public Material() {
        // 初始化渲染状态..

        // 初始化材质参数..

        // 设置默认着色器
        shader = new DefaultShader();
        shader.setMaterial(this);
    }

    public Shader getShader() {
        return shader;
    }

    public void setShader(Shader shader) {
        if (shader != null) {
            shader.setMaterial(this);
            this.shader = shader;
        }
    }

}

改造渲染管线

先在SoftwareRaster类中定义一个Shader成员,并提供set方法。

// 着色器
private Shader shader;

public void setShader(Shader shader) {
    this.shader = shader;
}

修改 rasterizePixel 方法,不再调用原来的 fragmentShader 方法,而是调用shader.fragmentShader()。

/**
 * 光栅化点
 * @param x
 * @param y
 * @param frag
 */
public void rasterizePixel(int x, int y, RasterizationVertex frag) {

    if (x < 0 || y < 0 || x >= width || y >= height) {
        return;
    }

    // 透视投影修正..

    // 执行片段着色器
    if ( !shader.fragmentShader(frag) )
        return;


    // 深度测试..

    // Alpha测试..

    // 颜色混合..

    // 写入depthBuffer..

    // 写入frameBuffer..
}

注意,为了实现着色器中的discard功能,我把fragmentShader方法的返回值设计为boolean类型,这样 fragmentShader 就可以通过 return false 来舍弃某些像素值。现在完全可以用 fragmentShader 来实现Alpha测试。

接着,修改 Renderer 类的 render(Geometry geometry) 方法。在执行光栅化之前,先把Material中的shader对象取出来,把各种矩阵的值设置给它,再把shader设给raster。

遍历三角形时,使用 shader.vertexShader() 来取代原来的 vertexShader 方法。

/**
 * 渲染单个物体
 * @param geometry
 */
protected void render(Geometry geometry) {

    // 设置材质
    this.material = geometry.getMaterial();
    // 设置渲染状态
    this.raster.setRenderState(material.getRenderState());

    // 设置着色器
    Shader shader = material.getShader();
    shader.setLights(lights);

    // 设置全局变量
    shader.setWorldMatrix(worldMatrix);
    shader.setViewMatrix(viewMatrix);
    shader.setProjectionMatrix(projectionMatrix);
    shader.setWorldViewMatrix(worldViewMatrix);
    shader.setViewProjectionMatrix(viewProjectionMatrix);
    shader.setWorldViewProjectionMatrix(worldViewProjectionMatrix);

    raster.setShader(shader);

    // 用于保存变换后的向量坐标。
    Vector3f a = new Vector3f();
    Vector3f b = new Vector3f();
    Vector3f c = new Vector3f();

    // 提取网格数据
    Mesh mesh = geometry.getMesh();
    int[] indexes = mesh.getIndexes();
    Vertex[] vertexes = mesh.getVertexes();

    // 遍历所有三角形
    for (int i = 0; i < indexes.length; i += 3) {

        Vertex v0 = vertexes[indexes[i]];
        Vertex v1 = vertexes[indexes[i+1]];
        Vertex v2 = vertexes[indexes[i+2]];

        // 执行顶点着色器
        RasterizationVertex out0 = shader.vertexShader(v0);
        RasterizationVertex out1 = shader.vertexShader(v1);
        RasterizationVertex out2 = shader.vertexShader(v2);

        // 在观察空间进行背面消隐
        worldViewMatrix.mult(v0.position, a);
        worldViewMatrix.mult(v1.position, b);
        worldViewMatrix.mult(v2.position, c);

        if (cullBackFace(a, b, c))
            continue;

        // TODO 视锥裁剪

        raster.rasterizeTriangle(out0, out1, out2);
    }
}

这样对渲染管线的改造就完成了。

测试着色器

UnshadedShader

创建一个UnshadedShader。

在顶点着色阶段,它将把Material中的Diffuse颜色赋予顶点。在片段着色阶段,它和DefaultShader一样把纹理采样的颜色赋予像素。

通过这个简单的着色器,就可以利用Material来改变物体表面的颜色了。

package net.jmecn.shader;

import net.jmecn.material.Texture;
import net.jmecn.math.Vector4f;
import net.jmecn.scene.RasterizationVertex;
import net.jmecn.scene.Vertex;

/**
 * Unshaded着色器
 * @author yanmaoyuan
 *
 */
public class UnshadedShader extends Shader {

    @Override
    public RasterizationVertex vertexShader(Vertex vertex) {
        RasterizationVertex out = copy(vertex);

        if (material.isUseVertexColor()) {
            out.color.multLocal(material.getDiffuse());
        } else {
            out.color.set(material.getDiffuse());
        }

        // 模型-观察-透视 变换
        worldViewProjectionMatrix.mult(out.position, out.position);

        return out;
    }

    @Override
    public boolean fragmentShader(RasterizationVertex frag) {
        Texture texture = material.getDiffuseMap();
        if (texture != null && frag.hasTexCoord) {
            Vector4f texColor = texture.sample2d(frag.texCoord);
            frag.color.multLocal(texColor);
        }

        return true;
    }

}

测试用例

写一个测试用例,实验一下UnshadedShader的作用。在这个测试用例中,我将使用下面这个素材:

代码如下:

package net.jmecn.examples;

import java.io.IOException;

import net.jmecn.Application;
import net.jmecn.material.Material;
import net.jmecn.material.Texture;
import net.jmecn.math.Vector3f;
import net.jmecn.math.Vector4f;
import net.jmecn.renderer.Camera;
import net.jmecn.renderer.Image;
import net.jmecn.scene.Geometry;
import net.jmecn.scene.shape.Box;
import net.jmecn.shader.UnshadedShader;

/**
 * 测试Unshaded Shader
 * @author yanmaoyuan
 *
 */
public class TestUnahdedShader extends Application {

    public static void main(String[] args) {
        TestUnahdedShader app = new TestUnahdedShader();
        app.setResolution(400, 300);
        app.setTitle("Test Unshaded Shader");
        app.setFrameRate(60);
        app.start();
    }

    @Override
    protected void initialize() {
        // 初始化摄像机
        Camera cam = getCamera();
        cam.lookAt(new Vector3f(2, 3, 4), Vector3f.ZERO, Vector3f.UNIT_Y);

        // 创建材质
        Material material = new Material();

        // 设置着色器
        material.setShader(new UnshadedShader());

        // 设置颜色
        material.setDiffuse(new Vector4f(1, 1, 1, 1));

        // 设置纹理
        try {
            // 加载一幅图片作为纹理
            Image image = new Image("res/Crate.png");
            Texture diffuseMap = new Texture(image);
            material.setDiffuseMap(diffuseMap);
        } catch (IOException e) {
            // 使用默认程序纹理
            material.setDiffuseMap(new Texture());
        }

        // 添加到场景中
        Geometry geometry = new Geometry(new Box(), material);
        rootNode.attachChild(geometry);
    }

    @Override
    protected void update(float delta) {}

}

运行效果如下图:

总结

一个基于Java着色器的渲染框架。。我真是疯了。