Effect Improvements (#3599)

* default material

* remove effects

* better builtin effects

* builtin primitives

* fix material

* builtin uniforms

* fix percision
This commit is contained in:
Yun Hsiao Wu
2018-12-07 14:38:53 +08:00
committed by pandamicro
parent 64adf77910
commit 1850cabe7b
65 changed files with 199 additions and 4104 deletions
-2
View File
@@ -12,5 +12,3 @@ node_modules
/.project
npm-debug.log
DebugInfos.json
cocos/3d/builtin/effects/index.json
+11 -23
View File
@@ -63,7 +63,7 @@ class Material extends Asset {
if (this.effectName !== val) this._setEffect(val);
}
get effectName() {
return this._effectAsset.name;
return this._effectAsset ? this._effectAsset.name : '';
}
/**
@@ -83,14 +83,7 @@ class Material extends Asset {
* @param {Material} mat
*/
copy(mat) {
this.effectAsset = mat.effectAsset;
for (let name in mat._defines) {
this.define(name, mat._defines[name]);
}
for (let name in mat._props) {
this.setProperty(name, mat._props[name]);
}
this._setEffect(mat.effectAsset);
}
/**
@@ -101,11 +94,8 @@ class Material extends Asset {
setProperty(name, val) {
this._props[name] = val;
if (this._effect) {
if (val instanceof Texture) {
this._effect.setProperty(name, val._texture);
} else {
this._effect.setProperty(name, val);
}
if (val instanceof Texture) this._effect.setProperty(name, val._texture);
else this._effect.setProperty(name, val);
}
}
@@ -116,18 +106,11 @@ class Material extends Asset {
*/
define(name, val) {
this._defines[name] = val;
if (this._effect) {
this._effect.define(name, val);
}
if (this._effect) this._effect.define(name, val);
}
onLoaded() {
this._setEffect(this.effectAsset);
if (!this._effect) return;
for (let def in this._defines)
this._effect.define(def, this._defines[def]);
for (let prop in this._props)
this.setProperty(prop, this._props[prop]);
}
_setEffect(val) {
@@ -137,7 +120,12 @@ class Material extends Asset {
return;
}
this._effectAsset = effectAsset;
this._effect = effectAsset ? Effect.parseEffect(effectAsset) : null;
if (!effectAsset) return;
this._effect = Effect.parseEffect(effectAsset);
for (let def in this._defines)
this._effect.define(def, this._defines[def]);
for (let prop in this._props)
this.setProperty(prop, this._props[prop]);
}
static getInstantiatedMaterial(mat, rndCom) {
-31
View File
@@ -1,31 +0,0 @@
%{
"techniques": [
{
"queue": "overlay",
"lod": 0,
"passes": [
{
"vert": "sprite-vs:vert",
"frag": "sprite-fs:frag",
"stage": "default",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "one",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
}
}
%}
-143
View File
@@ -1,143 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 0,
"passes": [
{
"vert": "gizmo-vs",
"frag": "gizmo-fs",
"stage": "default",
"cullMode": "none",
"depthTest": false,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"color": {
"type": "color4",
"value": [1, 1, 1, 1]
}
}
%}
%% gizmo-vs {
attribute vec3 a_position;
attribute vec3 a_normal;
uniform mat4 model;
uniform mat4 viewProj;
uniform mat3 normalMatrix;
varying vec3 normal_w;
varying vec3 pos_w;
varying vec3 pos_l;
void main () {
vec4 pos = vec4(a_position, 1);
pos_l = a_position;
pos_w = (model * pos).xyz;
normal_w = normalMatrix * a_normal;
gl_Position = viewProj * model * pos;
}
}
%% gizmo-fs {
#include <gamma-correction>
#include <rect-area-light>
uniform vec3 eye;
uniform vec4 color;
varying vec3 normal_w;
varying vec3 pos_w;
varying vec3 pos_l;
#if PLANE_CONTROLLER
#include <common>
uniform float width;
uniform float height;
uniform float rotx;
uniform float roty;
uniform vec3 center;
vec3 rotation_x(vec3 v, float a) {
vec3 r;
r.x = v.x;
r.y = v.y*cos(a) - v.z*sin(a);
r.z = v.y*sin(a) + v.z*cos(a);
return r;
}
vec3 rotation_y(vec3 v, float a) {
vec3 r;
r.x = v.x*cos(a) + v.z*sin(a);
r.y = v.y;
r.z = -v.x*sin(a) + v.z*cos(a);
return r;
}
vec3 rotation_xy(vec3 v, float ax, float ay) {
return rotation_y(rotation_x(v, ax), ay);
}
struct Rect {
vec3 center;
vec3 dirx;
vec3 diry;
float halfx;
float halfy;
};
void InitRect(out Rect rect)
{
rect.center = center;
rect.dirx = rotation_xy(vec3(1, 0, 0), rotx * PI2, roty * PI2);
rect.diry = rotation_xy(vec3(0, 1, 0), rotx * PI2, roty * PI2);
rect.halfx = 0.5 * width;
rect.halfy = 0.5 * height;
}
void InitRectPoints(Rect rect, out vec3 points[4])
{
vec3 ex = rect.halfx * rect.dirx;
vec3 ey = rect.halfy * rect.diry;
points[0] = rect.center - ex - ey;
points[1] = rect.center + ex - ey;
points[2] = rect.center + ex + ey;
points[3] = rect.center - ex + ey;
}
#endif
void main () {
vec3 N = normalize(normal_w);
vec3 V = normalize(eye - pos_w);
// vec3 L = normalize(vec3(1, 2, 3));
// vec3 diffuse = color.rgb * (0.2 + max(0.0, dot(N, L)) * 0.8);
vec3 points[4];
#if PLANE_CONTROLLER
Rect rect;
InitRect(rect);
InitRectPoints(rect, points);
#else
// { center: (30, 40, 50), width: 40, height: 40, rotx: -0.125, roty: 0.125 }
points[0] = vec3(25.86, 25.86, 74.14);
points[1] = vec3(54.14, 25.86, 45.86);
points[2] = vec3(34.14, 54.14, 25.86);
points[3] = vec3(5.86, 54.14, 54.14);
#endif
vec3 diffuse = color.rgb * (0.2 + LTC_Evaluate(N, V, pos_l, mat3(1), points) * 0.8);
gl_FragColor = linearToGammaSpaceRGBA(vec4(diffuse, color.a));
}
}
-178
View File
@@ -1,178 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 100,
"passes": [
{
"vert": "grid-vs",
"frag": "grid-fs",
"stage": "default"
}
]
}
],
"properties": {
"tiling": {
"type": "vec2",
"value": [1, 1]
},
"baseColorWhite": {
"type": "color3",
"value": [1, 1, 1]
},
"baseColorBlack": {
"type": "color3",
"value": [0, 0, 0]
},
"basePattern": {
"type": "sampler2D",
"value": null
},
"basePatternTiling": {
"type": "vec2",
"value": [1, 1]
},
"basePatternOffset": {
"type": "vec2",
"value": [0, 0]
},
"subPatternColor": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"subPattern": {
"type": "sampler2D",
"value": null
},
"subPatternTiling": {
"type": "vec2",
"value": [1, 1]
},
"subPatternOffset": {
"type": "vec2",
"value": [0, 0]
},
"subPatternColor2": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"subPattern2": {
"type": "sampler2D",
"value": null
},
"subPattern2Tiling": {
"type": "vec2",
"value": [1, 1]
},
"subPattern2Offset": {
"type": "vec2",
"value": [0, 0]
}
}
%}
%% grid-vs {
attribute vec2 a_uv0;
attribute vec3 a_position;
attribute vec3 a_normal;
uniform mat4 model;
uniform mat4 viewProj;
varying vec2 uv0;
varying vec4 pos_w;
#if USE_WORLD_POS
uniform mat3 normalMatrix;
varying vec3 normal_w;
#endif
void main () {
uv0 = a_uv0;
pos_w = model * vec4(a_position, 1);
#if USE_WORLD_POS
normal_w = normalMatrix * a_normal;
#endif
gl_Position = viewProj * pos_w;
}
}
%% grid-fs {
varying vec2 uv0;
varying vec4 pos_w;
#if USE_WORLD_POS
varying vec3 normal_w;
#endif
uniform vec2 tiling;
uniform vec3 baseColorWhite;
uniform vec3 baseColorBlack;
uniform sampler2D basePattern;
uniform vec2 basePatternTiling;
uniform vec2 basePatternOffset;
uniform vec4 subPatternColor;
uniform sampler2D subPattern;
uniform vec2 subPatternTiling;
uniform vec2 subPatternOffset;
uniform vec4 subPatternColor2;
uniform sampler2D subPattern2;
uniform vec2 subPattern2Tiling;
uniform vec2 subPattern2Offset;
void main () {
vec2 uv = uv0 * tiling;
vec2 uvBase = uv * basePatternTiling + basePatternOffset;
vec2 uvSub = uv * subPatternTiling + subPatternOffset;
vec2 uvSub2 = uv * subPattern2Tiling + subPattern2Offset;
#if USE_WORLD_POS
vec3 dnormal_w = normalize(normal_w);
if (abs(dnormal_w.x)>0.5) { // side
uvBase = (pos_w.zy * tiling * basePatternTiling) + basePatternOffset;
uvSub = (pos_w.zy * tiling * subPatternTiling) + subPatternOffset;
uvSub2 = (pos_w.zy * tiling * subPattern2Tiling) + subPattern2Offset;
} else if (abs(dnormal_w.z)>0.5) { // front
uvBase = (pos_w.xy * tiling * basePatternTiling) + basePatternOffset;
uvSub = (pos_w.xy * tiling * subPatternTiling) + subPatternOffset;
uvSub2 = (pos_w.xy * tiling * subPattern2Tiling) + subPattern2Offset;
} else { // top
uvBase = (pos_w.xz * tiling * basePatternTiling) + basePatternOffset;
uvSub = (pos_w.xz * tiling * subPatternTiling) + subPatternOffset;
uvSub2 = (pos_w.xz * tiling * subPattern2Tiling) + subPattern2Offset;
}
#endif
vec4 texColBase = texture2D(basePattern, uvBase);
vec4 texColSub = texture2D(subPattern, uvSub);
vec4 texColSub2 = texture2D(subPattern2, uvSub2);
// texColBase.rgb = gammaToLinearSpace(texColBase.rgb);
// texColSub.rgb = gammaToLinearSpace(texColSub.rgb);
// texColSub2.rgb = gammaToLinearSpace(texColSub2.rgb);
vec4 color = vec4(baseColorWhite,1) * texColBase + vec4(baseColorBlack,1) * (1.0-texColBase);
color =
color * (1.0 - texColSub) +
(subPatternColor * subPatternColor.a + color * (1.0-subPatternColor.a)) * texColSub
;
color =
color * (1.0 - texColSub2) +
(subPatternColor2 * subPatternColor2.a + color * (1.0-subPatternColor2.a)) * texColSub2
;
// gamma correction.
// color.rgb = linearToGammaSpace(color.rgb);
gl_FragColor = color;
}
}
-61
View File
@@ -1,61 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 100,
"passes": [
{
"vert": "line-vs",
"frag": "line-fs",
"stage": "default",
"depthTest": true
}
]
}
],
"properties": {}
%}
%% line-vs {
attribute vec3 a_position;
attribute vec3 a_color;
uniform mat4 model;
uniform mat4 viewProj;
varying vec3 color;
void main () {
vec4 pos = viewProj * model * vec4(a_position, 1);
// // halp-pixel offset solution 1
// vec4 pos = viewProj * model * vec4(
// floor(a_position.x) + 0.5,
// floor(a_position.y) + 0.5,
// a_position.z,
// 1
// );
// halp-pixel offset solution 2
// vec2 hpc = vec2(screen.x * 0.5, screen.y * 0.5);
// vec4 pos = viewProj * model * vec4(a_position, 1);
// pos = vec4(
// 2.0 * ((floor((pos.x + 1.0) * 0.5 * screen.x) + 0.5) / screen.x - 0.5),
// 2.0 * ((floor((pos.y + 1.0) * 0.5 * screen.y) - 0.5) / screen.y - 0.5),
// pos.z,
// pos.w
// );
color = a_color;
gl_Position = pos;
}
}
%% line-fs {
varying vec3 color;
void main () {
gl_FragColor = vec4(color, 1.0);
}
}
-98
View File
@@ -1,98 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 100,
"passes": [
{
"vert": "matcap-vs",
"frag": "matcap-fs",
"stage": "default",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"mainTex": {
"type": "sampler2D",
"value": null
},
"matcapTex": {
"type": "sampler2D",
"value": null
},
"colorFactor": {
"type": "float",
"value": 0.5
},
"color": {
"type": "color4",
"value": [1, 1, 1, 1]
}
}
%}
%% matcap-vs {
attribute vec3 a_position;
attribute vec3 a_normal;
uniform mat4 model;
uniform mat4 viewProj;
uniform mat3 normalMatrix;
varying vec2 matcapUV;
#if USE_MAIN_TEX
attribute vec2 a_uv0;
varying vec2 uv0;
#endif
#if USE_SKINNING
#include <skinning>
#endif
void main(void){
#if USE_MAIN_TEX
uv0 = a_uv0;
#endif
vec4 pos = vec4(a_position, 1);
#if USE_SKINNING
mat4 skinMat = skinMatrix();
pos = skinMat * pos;
#endif
pos = viewProj * model * pos;
gl_Position = pos;
vec4 normal = vec4(a_normal, 0);
#if USE_SKINNING
normal = skinMat * normal;
#endif
normal = vec4(normalize(normalMatrix * normal.xyz), 0);
matcapUV = normal.xy;
matcapUV = matcapUV * 0.5 + 0.5;
}
}
%% matcap-fs {
uniform sampler2D matcapTex;
uniform float colorFactor;
uniform vec4 color;
varying vec2 matcapUV;
#if USE_MAIN_TEX
varying vec2 uv0;
uniform sampler2D mainTex;
#endif
void main(void){
vec4 col = vec4(1, 1, 1, 1);
col *= color;
#if USE_MAIN_TEX
col *= texture2D(mainTex, uv0);
#endif
vec4 matcapColor = texture2D(matcapTex, matcapUV);
gl_FragColor = col * colorFactor + matcapColor * (1.0 - colorFactor);
}
}
@@ -1,68 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 300,
"passes": [
{
"vert": "particle-vs-gpu:gpvs_main",
"frag": "particle-add-gpu-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "one",
"blendAlphaEq": "add",
"blendSrcAlpha": "srcAlpha",
"blendDstAlpha": "one"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"tintColor": {
"type": "color4",
"value": [0.5, 0.5, 0.5, 0.5]
},
"frameTile": {
"type": "vec2",
"value": [1, 1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-add-gpu-fs {
uniform sampler2D mainTexture;
uniform vec4 tintColor;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
gl_FragColor = 2.0 * color * tintColor * texture2D(mainTexture, uv);
}
}
@@ -1,73 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 200,
"passes": [
{
"vert": "particle-vs-legacy:lpvs_main",
"frag": "particle-add-multiply-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "one",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"tintColor": {
"type": "color4",
"value": [0.5, 0.5, 0.5, 0.5]
},
"frameTile": {
"type": "vec2",
"value": [1,1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-add-multiply-fs {
uniform sampler2D mainTexture;
uniform vec4 tintColor;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
vec4 col;
vec4 texColor = texture2D(mainTexture, uv);
col.rgb = tintColor.rgb * texColor.rgb * color.rgb * vec3(2.0);
col.a = (1.0 - texColor.a) * (tintColor.a * color.a * 2.0);
gl_FragColor = col;
}
}
@@ -1,65 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"passes": [
{
"vert": "particle-vs-legacy:lpvs_main",
"frag": "particle-add-smooth-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "one",
"blendDst": "oneMinusSrcColor",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcColor"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"frameTile": {
"type": "vec2",
"value": [1,1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-add-smooth-fs {
uniform sampler2D mainTexture;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
vec4 col = color * texture2D(mainTexture, uv);
col.rgb *= col.a;
gl_FragColor = col;
}
}
@@ -1,69 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 200,
"passes": [
{
"vert": "particle-vs-legacy:lpvs_main",
"frag": "particle-add-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "one",
"blendAlphaEq": "add",
"blendSrcAlpha": "srcAlpha",
"blendDstAlpha": "one"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"tintColor": {
"type": "color4",
"value": [0.5, 0.5, 0.5, 0.5]
},
"frameTile": {
"type": "vec2",
"value": [1,1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-add-fs {
uniform sampler2D mainTexture;
uniform vec4 tintColor;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
gl_FragColor = 2.0 * color * tintColor * texture2D(mainTexture, uv);
}
}
@@ -1,69 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 200,
"passes": [
{
"vert": "particle-vs-legacy:lpvs_main",
"frag": "particle-alpha-blend-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "srcAlpha",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"tintColor": {
"type": "color4",
"value": [0.5, 0.5, 0.5, 0.5]
},
"frameTile": {
"type": "vec2",
"value": [1,1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-alpha-blend-fs {
uniform sampler2D mainTexture;
uniform vec4 tintColor;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
gl_FragColor = 2.0 * color * tintColor * texture2D(mainTexture, uv);
}
}
@@ -1,62 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"passes": [
{
"vert": "particle-vs-legacy:lpvs_main",
"frag": "particle-premultiply-blend-fs",
"stage": "default",
"cullMode": "none",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "one",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"frameTile": {
"type": "vec2",
"value": [1,1]
},
"velocityScale": {
"type": "float",
"value": 0
},
"lengthScale": {
"type": "float",
"value": 0
}
}
%}
%% particle-premultiply-blend-fs {
uniform sampler2D mainTexture;
varying vec2 uv;
varying vec4 color;
void main () {
// TODO: soft particle
gl_FragColor = color * texture2D(mainTexture, uv) * color.a;
}
}
@@ -1,113 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 500,
"passes": [
{
"vert": "pbr-vs:vert",
"frag": "pbr-fs:frag",
"stage": "forward",
"cullMode": "back",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
},
{
"vert": "shadow-depth-vs:vert",
"frag": "shadow-depth-fs:frag",
"stage": "shadowcast",
"cullMode": "back",
"blendMode": "none",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"albedo": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"albedo_texture": {
"type": "sampler2D",
"value": null
},
"metallic": {
"type": "float",
"value": 1
},
"metallic_texture": {
"type": "sampler2D",
"value": null
},
"roughness": {
"type": "float",
"value": 0.5
},
"roughness_texture": {
"type": "sampler2D",
"value": null
},
"ao": {
"type": "float",
"value": 0.2
},
"ao_texture": {
"type": "sampler2D",
"value": null
},
"mra_texture": {
"type": "sampler2D",
"value": null
},
"emissive": {
"type": "color3",
"value": [0, 0, 0]
},
"emissive_texture": {
"type": "sampler2D",
"value": null
},
"normal_texture": {
"type": "sampler2D",
"value": null
},
"diffuseEnvTexture": {
"type": "samplerCube",
"value": null
},
"specularEnvTexture": {
"type": "samplerCube",
"value": null
},
"brdfLUT": {
"type": "sampler2D",
"value": null
},
"maxReflectionLod": {
"type": "float",
"value": 9
},
"alphaTestThreshold": {
"type": "float",
"value": 0
}
}
%}
-103
View File
@@ -1,103 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
%{
"techniques": [
{
"queue": "opaque",
"lod": 500,
"passes": [
{
"vert": "pbr-vs:vert",
"frag": "pbr-fs:frag",
"stage": "forward",
"cullMode": "back",
"depthTest": true,
"depthWrite": true
},
{
"vert": "shadow-depth-vs:vert",
"frag": "shadow-depth-fs:frag",
"stage": "shadowcast",
"cullMode": "back",
"blendMode": "none",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"albedo": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"albedo_texture": {
"type": "sampler2D",
"value": null
},
"metallic": {
"type": "float",
"value": 1
},
"metallic_texture": {
"type": "sampler2D",
"value": null
},
"roughness": {
"type": "float",
"value": 0.5
},
"roughness_texture": {
"type": "sampler2D",
"value": null
},
"ao": {
"type": "float",
"value": 0.2
},
"ao_texture": {
"type": "sampler2D",
"value": null
},
"mra_texture": {
"type": "sampler2D",
"value": null
},
"emissive": {
"type": "color3",
"value": [0, 0, 0]
},
"emissive_texture": {
"type": "sampler2D",
"value": null
},
"normal_texture": {
"type": "sampler2D",
"value": null
},
"diffuseEnvTexture": {
"type": "samplerCube",
"value": null
},
"specularEnvTexture": {
"type": "samplerCube",
"value": null
},
"brdfLUT": {
"type": "sampler2D",
"value": null
},
"maxReflectionLod": {
"type": "float",
"value": 9
}
}
%}
@@ -1,80 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"lod": 200,
"passes": [
{
"vert": "phong-vs:vert",
"frag": "phong-fs:frag",
"stage": "forward",
"cullMode": "back",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
},
{
"vert": "shadow-depth-vs:vert",
"frag": "shadow-depth-fs:frag",
"stage": "shadowcast",
"cullMode": "back",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"diffuseColor": {
"type": "color4",
"value": [0.8, 0.8, 0.8, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"diffuse_texture": {
"type": "sampler2D",
"value": null
},
"specularColor": {
"type": "color3",
"value": [0, 0, 0]
},
"specular_texture": {
"type": "sampler2D",
"value": null
},
"emissiveColor": {
"type": "color3",
"value": [0, 0, 0]
},
"emissive_texture": {
"type": "sampler2D",
"value": null
},
"glossiness": {
"type": "float",
"value": 10
},
"normal_texture": {
"type": "sampler2D",
"value": null
},
"alphaTestThreshold": {
"type": "float",
"value": 0
}
}
%}
-73
View File
@@ -1,73 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 200,
"passes": [
{
"vert": "phong-vs:vert",
"frag": "phong-fs:frag",
"stage": "forward",
"cullMode": "back",
"depthTest": true,
"depthWrite": true
},
{
"vert": "shadow-depth-vs:vert",
"frag": "shadow-depth-fs:frag",
"stage": "shadowcast",
"cullMode": "back",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"diffuseColor": {
"type": "color4",
"value": [0.8, 0.8, 0.8, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"diffuse_texture": {
"type": "sampler2D",
"value": null
},
"specularColor": {
"type": "color3",
"value": [0, 0, 0]
},
"specular_texture": {
"type": "sampler2D",
"value": null
},
"emissiveColor": {
"type": "color3",
"value": [0, 0, 0]
},
"emissive_texture": {
"type": "sampler2D",
"value": null
},
"glossiness": {
"type": "float",
"value": 10
},
"normal_texture": {
"type": "sampler2D",
"value": null
},
"alphaTestThreshold": {
"type": "float",
"value": 0
}
}
%}
-74
View File
@@ -1,74 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"passes": [
{
"vert": "sp-vs",
"frag": "sp-fs",
"stage": "default",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"color": {
"type": "color4",
"value": [0.4, 0.4, 0.4, 1]
}
}
%}
%% sp-vs {
attribute vec3 a_position;
uniform mat4 model;
uniform mat4 viewProj;
#if USE_TEXTURE
attribute vec2 a_uv0;
varying vec2 uv0;
#endif
void main () {
vec4 pos = viewProj * model * vec4(a_position, 1);
#if USE_TEXTURE
uv0 = a_uv0;
#endif
gl_Position = pos;
}
}
%% sp-fs {
#if USE_TEXTURE
uniform sampler2D texture;
varying vec2 uv0;
#endif
#if USE_COLOR
uniform vec4 color;
#endif
void main () {
vec4 o = vec4(1, 1, 1, 1);
#if USE_TEXTURE
o *= texture2D(texture, uv0);
#endif
#if USE_COLOR
o *= color;
#endif
if (!gl_FrontFacing) {
o.rgb *= 0.5;
}
gl_FragColor = o;
}
}
-59
View File
@@ -1,59 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"priority" : -1000,
"lod": 200,
"passes": [
{
"vert": "sky-vs",
"frag": "sky-fs",
"stage": "default",
"cullMode": "none"
}
]
}
],
"properties": {
"cubeMap": {
"type": "samplerCube",
"value": null
}
}
%}
%% sky-vs {
attribute vec3 a_position;
uniform mat4 view;
uniform mat4 proj;
varying vec3 viewDir;
void main() {
mat4 rotView = mat4(mat3(view));
vec4 clipPos = proj * rotView * vec4(a_position, 1.0);
gl_Position = clipPos.xyww;
viewDir = a_position;
}
}
%% sky-fs {
varying vec3 viewDir;
uniform samplerCube cubeMap;
#include <gamma-correction>
#include <unpack>
void main() {
#if USE_RGBE_CUBEMAP
vec3 c = unpackRGBE(textureCube(cubeMap, viewDir));
c = linearToGammaSpaceRGB(c / (1.0 + c));
gl_FragColor = vec4(c, 1.0);
#else
gl_FragColor = textureCube(cubeMap, viewDir);
#endif
}
}
-30
View File
@@ -1,30 +0,0 @@
%{
"techniques": [
{
"queue": "overlay",
"passes": [
{
"vert": "sprite-vs:vert",
"frag": "sprite-fs:frag",
"stage": "default",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"mainTexture": {
"type": "sampler2D",
"value": null
}
}
%}
@@ -1,43 +0,0 @@
%{
"techniques": [
{
"queue": "transparent",
"passes": [
{
"vert": "unlit-vs:vert",
"frag": "unlit-fs:frag",
"stage": "default",
"cullMode": "back",
"depthTest": true,
"depthWrite": false,
"blend": true,
"blendEq": "add",
"blendSrc": "srcAlpha",
"blendDst": "oneMinusSrcAlpha",
"blendAlphaEq": "add",
"blendSrcAlpha": "one",
"blendDstAlpha": "oneMinusSrcAlpha"
}
]
}
],
"properties": {
"color": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"mainTexture": {
"type": "sampler2D",
"value": null
}
}
%}
-37
View File
@@ -1,37 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 100,
"passes": [
{
"vert": "unlit-vs:vert",
"frag": "unlit-fs:frag",
"stage": "default",
"cullMode": "back",
"depthTest": true,
"depthWrite": true
}
]
}
],
"properties": {
"color": {
"type": "color4",
"value": [1, 1, 1, 1]
},
"mainTiling": {
"type": "vec2",
"value": [1, 1]
},
"mainOffset": {
"type": "vec2",
"value": [0, 0]
},
"mainTexture": {
"type": "sampler2D",
"value": null
}
}
%}
-60
View File
@@ -1,60 +0,0 @@
%{
"techniques": [
{
"queue": "opaque",
"lod": 100,
"passes": [
{
"vert": "wire-vs",
"frag": "wire-fs",
"stage": "default",
"depthTest": true
}
]
}
],
"properties": {
"color": {
"type": "color3",
"value": [1, 1, 1]
}
}
%}
%% wire-vs {
attribute vec3 a_position;
attribute vec3 a_normal;
uniform mat4 model, viewProj;
uniform mat3 normalMatrix;
varying vec3 position_w;
varying vec3 normal_w;
void main () {
vec4 pos = vec4(a_position, 1);
position_w = (model * pos).xyz;
pos = viewProj * model * pos;
normal_w = normalMatrix * a_normal.xyz;
gl_Position = pos;
}
}
%% wire-fs {
uniform vec3 eye;
uniform vec3 color;
varying vec3 position_w;
varying vec3 normal_w;
void main () {
gl_FragColor = vec4(color, 1.0);
vec3 V = normalize(eye - position_w);
if (dot (normal_w, V) <= 0.0) {
gl_FragColor.rgb *= 0.6;
}
}
}
+26 -6
View File
@@ -1,10 +1,13 @@
import Texture2D from '../../assets/CCTexture2D';
import TextureCube from '../assets/texture-cube';
import ImageAsset from '../../assets/image-asset';
import Material from '../assets/material';
import EffectAsset from '../assets/effect-asset';
let builtinResMgr = {
// this should be called after renderer initialized
initBuiltinRes: function(device, effectUUIDs, OnComplete) {
initBuiltinRes: function(device) {
builtinResMgr.device = device;
let canvas = document.createElement('canvas');
let context = canvas.getContext('2d');
@@ -69,28 +72,45 @@ let builtinResMgr = {
whiteTexture._uuid = 'white-texture';
defaultTexture.image = canvasImage;
// classic ugly pink indicating missing material
let pinkEffect = new EffectAsset();
pinkEffect.name = 'default';
pinkEffect.techniques.push({ passes: [{ program: 'default' }] });
pinkEffect.shaders.push({
name: 'default',
vert: `attribute vec3 a_position; \n uniform mat4 _model; \n uniform mat4 _viewProj; \n void main() { gl_Position = _viewProj * _model * vec4(a_position, 1); }`,
frag: `void main() { gl_FragColor = vec4(1, 0, 1, 1); }`,
uniforms: [], defines: [], attributes: [], extensions: []
});
pinkEffect.onLoaded();
let defaultMtl = new Material();
defaultMtl._uuid = 'default-material';
defaultMtl.effectAsset = pinkEffect;
let builtins = {
[defaultTexture._uuid]: defaultTexture,
[defaultTextureCube._uuid]: defaultTextureCube,
[blackTexture._uuid]: blackTexture,
[whiteTexture._uuid]: whiteTexture,
[defaultMtl._uuid]: defaultMtl
};
return Object.assign(builtinResMgr, builtins);
},
initEffects(effectUUIDs, OnComplete) {
// ============================
// async builtin effects
// ============================
let remainingJobs = effectUUIDs.length;
for (let i = 0; i < effectUUIDs.length; ++i) {
let uuid = effectUUIDs[i];
cc.AssetLibrary.loadAsset(uuid, (err, asset) => {
if (err) { console.error(err); return; }
cc.EffectAsset.register(asset);
if (!--remainingJobs) OnComplete(builtins);
if (!--remainingJobs) OnComplete(builtinResMgr);
});
}
},
}
};
cc._builtinResMgr = builtinResMgr;
cc.BuiltinResMgr = builtinResMgr;
export default builtinResMgr;
+1 -1
View File
@@ -71,7 +71,7 @@ let CameraProjection = Enum({
@ccclass('cc.CameraComponent')
@menu('Components/CameraComponent')
export default class CameraComponent extends RenderSystemActor{
@property
@property(CameraProjection)
_projection = CameraProjection.Perspective;
@property
+1 -8
View File
@@ -275,13 +275,6 @@ export default class ModelComponent extends RenderableComponent {
_getBuiltinMaterial() {
// classic ugly pink indicating missing material
if (ModelComponent._builtinMaterial === null) {
const builtinMaterial = new cc.Material();
builtinMaterial.effectName = 'builtin-effect-unlit';
builtinMaterial.define("USE_COLOR", true);
builtinMaterial.setProperty("color", new cc.Color(255, 0, 255, 255));
ModelComponent._builtinMaterial = builtinMaterial;
}
return ModelComponent._builtinMaterial;
return cc.BuiltinResMgr['default-material'];
}
}
-77
View File
@@ -1,77 +0,0 @@
// this file is used for offline effect building.
import { enums } from '../../renderer/gfx/enums';
import rendererEnums from '../../renderer/enums';
import { RenderQueue, PassStage } from '../../renderer/core/constants';
const typeParams = {
INT: rendererEnums.PARAM_INT,
IVEC2: rendererEnums.PARAM_INT2,
IVEC3: rendererEnums.PARAM_INT3,
IVEC4: rendererEnums.PARAM_INT4,
FLOAT: rendererEnums.PARAM_FLOAT,
VEC2: rendererEnums.PARAM_FLOAT2,
VEC3: rendererEnums.PARAM_FLOAT3,
VEC4: rendererEnums.PARAM_FLOAT4,
COLOR3: rendererEnums.PARAM_COLOR3,
COLOR4: rendererEnums.PARAM_COLOR4,
MAT2: rendererEnums.PARAM_MAT2,
MAT3: rendererEnums.PARAM_MAT3,
MAT4: rendererEnums.PARAM_MAT4,
SAMPLER2D: rendererEnums.PARAM_TEXTURE_2D,
SAMPLERCUBE: rendererEnums.PARAM_TEXTURE_CUBE,
[rendererEnums.PARAM_FLOAT3]: rendererEnums.PARAM_COLOR3,
[rendererEnums.PARAM_FLOAT4]: rendererEnums.PARAM_COLOR4
};
const passParams = {
BACK: enums.CULL_BACK,
FRONT: enums.CULL_FRONT,
NONE: enums.CULL_NONE,
ADD: enums.BLEND_FUNC_ADD,
SUBTRACT: enums.BLEND_FUNC_SUBTRACT,
REVERSESUBTRACT: enums.BLEND_FUNC_REVERSE_SUBTRACT,
ZERO: enums.BLEND_ZERO,
ONE: enums.BLEND_ONE,
SRCCOLOR: enums.BLEND_SRC_COLOR,
ONEMINUSSRCCOLOR: enums.BLEND_ONE_MINUS_SRC_COLOR,
DSTCOLOR: enums.BLEND_DST_COLOR,
ONEMINUSDSTCOLOR: enums.BLEND_ONE_MINUS_DST_COLOR,
SRCALPHA: enums.BLEND_SRC_ALPHA,
ONEMINUSSRCALPHA: enums.BLEND_ONE_MINUS_SRC_ALPHA,
DSTALPHA: enums.BLEND_DST_ALPHA,
ONEMINUSDSTALPHA: enums.BLEND_ONE_MINUS_DST_ALPHA,
CONSTCOLOR: enums.BLEND_CONSTANT_COLOR,
ONEMINUSCONSTCOLOR: enums.BLEND_ONE_MINUS_CONSTANT_COLOR,
CONSTALPHA: enums.BLEND_CONSTANT_ALPHA,
ONEMINUSCONSTALPHA: enums.BLEND_ONE_MINUS_CONSTANT_ALPHA,
SRCALPHASATURATE: enums.BLEND_SRC_ALPHA_SATURATE,
NEVER: enums.DS_FUNC_NEVER,
LESS: enums.DS_FUNC_LESS,
EQUAL: enums.DS_FUNC_EQUAL,
LEQUAL: enums.DS_FUNC_LEQUAL,
GREATER: enums.DS_FUNC_GREATER,
NOTEQUAL: enums.DS_FUNC_NOTEQUAL,
GEQUAL: enums.DS_FUNC_GEQUAL,
ALWAYS: enums.DS_FUNC_ALWAYS,
KEEP: enums.STENCIL_OP_KEEP,
REPLACE: enums.STENCIL_OP_REPLACE,
INCR: enums.STENCIL_OP_INCR,
INCR_WRAP: enums.STENCIL_OP_INCR_WRAP,
DECR: enums.STENCIL_OP_DECR,
DECR_WRAP: enums.STENCIL_OP_DECR_WRAP,
INVERT: enums.STENCIL_OP_INVERT
};
Object.assign(passParams, PassStage);
let mappings = {
typeParams,
passParams,
RenderQueue
};
export default mappings;
+2 -2
View File
@@ -17,8 +17,8 @@ let temp2 = vec3.create(0, 0, 0);
*/
export default function (radiusTop = 0.5, radiusBottom = 0.5, height = 2, opts = {}) {
let torsoHeight = height - radiusTop - radiusBottom;
let sides = opts.sides || 16;
let heightSegments = opts.heightSegments || 10;
let sides = opts.sides || 32;
let heightSegments = opts.heightSegments || 32;
let bottomProp = radiusBottom / height;
let torProp = torsoHeight / height;
let topProp = radiusTop / height;
+1 -1
View File
@@ -17,7 +17,7 @@ let temp2 = vec3.create(0, 0, 0);
*/
export default function (radiusTop = 0.5, radiusBottom = 0.5, height = 2, opts = {}) {
let halfHeight = height * 0.5;
let radialSegments = opts.radialSegments || 8;
let radialSegments = opts.radialSegments || 32;
let heightSegments = opts.heightSegments || 1;
let capped = opts.capped !== undefined ? opts.capped : true;
let arc = opts.arc || 2.0 * Math.PI;
+3 -3
View File
@@ -17,9 +17,9 @@ let c01 = vec3.create(0, 0, 0);
* @param {Number} opts.widthSegments
* @param {Number} opts.lengthSegments
*/
export default function (width, length, opts = {}) {
let uSegments = opts.widthSegments !== undefined ? opts.widthSegments : 5;
let vSegments = opts.lengthSegments !== undefined ? opts.lengthSegments : 5;
export default function (width = 10, length = 10, opts = {}) {
let uSegments = opts.widthSegments !== undefined ? opts.widthSegments : 10;
let vSegments = opts.lengthSegments !== undefined ? opts.lengthSegments : 10;
let hw = width * 0.5;
let hl = length * 0.5;
+2 -2
View File
@@ -8,7 +8,7 @@ import { vec3 } from '../../core/vmath';
* @param {Number} opts.segments
*/
export default function (radius = 0.5, opts = {}) {
let segments = opts.segments !== undefined ? opts.segments : 16;
let segments = opts.segments !== undefined ? opts.segments : 32;
// lat === latitude
// lon === longitude
@@ -64,4 +64,4 @@ export default function (radius = 0.5, opts = {}) {
maxPos,
boundingRadius
};
}
}
+4 -4
View File
@@ -9,9 +9,9 @@ import { vec3 } from '../../core/vmath';
* @param {Number} opts.tubularSegments
* @param {Number} opts.arc
*/
export default function (radius = 0.5, tube = 0.2, opts = {}) {
let radialSegments = opts.radialSegments || 30;
let tubularSegments = opts.tubularSegments || 20;
export default function (radius = 0.4, tube = 0.1, opts = {}) {
let radialSegments = opts.radialSegments || 32;
let tubularSegments = opts.tubularSegments || 32;
let arc = opts.arc || 2.0 * Math.PI;
let positions = [];
@@ -66,4 +66,4 @@ export default function (radius = 0.5, tube = 0.2, opts = {}) {
maxPos,
boundingRadius
};
}
}
+28
View File
@@ -23,6 +23,34 @@ export function wireframe(indices) {
return lines;
}
/**
* @param {Array} indices
*/
export function invWinding(indices) {
let newIB = [];
for (let i = 0; i < indices.length; i += 3)
newIB.push(indices[i], indices[i + 2], indices[i + 1]);
return newIB;
}
/**
* @param {Array} indices
*/
export function toWavefrontOBJ(primitive) {
let v = primitive.positions, t = primitive.uvs, n = primitive.normals, IB = primitive.indices;
let V = i => `${IB[i]+1}/${IB[i]+1}/${IB[i]+1}`;
let content = '';
for (let i = 0; i < v.length; i += 3)
content += `v ${v[i]} ${v[i+1]} ${v[i+2]}\n`;
for (let i = 0; i < t.length; i += 2)
content += `vt ${t[i]} ${t[i+1]}\n`;
for (let i = 0; i < n.length; i += 3)
content += `vn ${n[i]} ${n[i+1]} ${n[i+2]}\n`;
for (let i = 0; i < IB.length; i += 3)
content += `f ${V(i)} ${V(i+1)} ${V(i+2)}\n`;
return content;
}
/**
* @param {Array} positions
* @param {Array} normals
+13 -15
View File
@@ -364,17 +364,17 @@ var game = {
// Init engine
this._initEngine();
this._initBuiltins(this.config.effects, () => {
// Log engine version
console.log('Cocos3D v' + cc.ENGINE_VERSION);
this._initBuiltins();
this._setAnimFrame();
this._runMainLoop();
// Log engine version
console.log('Cocos3D v' + cc.ENGINE_VERSION);
this.emit(this.EVENT_GAME_INITED);
this._setAnimFrame();
this._runMainLoop();
if (cb) cb();
});
this.emit(this.EVENT_GAME_INITED);
if (cb) cb();
},
eventTargetOn: EventTarget.prototype.on,
@@ -795,13 +795,11 @@ var game = {
this._rendererInitialized = true;
},
_initBuiltins: function(effectUUIDs, cb) {
builtinResMgr.initBuiltinRes(this._renderContext, effectUUIDs, (builtins) => {
this._renderer.setBuiltins({
defaultTexture: builtins['default-texture']._texture,
defaultTextureCube: builtins['default-texture-cube']._texture,
});
if (cb) cb();
_initBuiltins: function() {
let builtins = builtinResMgr.initBuiltinRes(this._renderContext);
this._renderer.setBuiltins({
defaultTexture: builtins['default-texture']._texture,
defaultTextureCube: builtins['default-texture-cube']._texture,
});
},
+2 -2
View File
@@ -744,12 +744,12 @@ class quat {
let x = q.x, y = q.y, z = q.z, w = q.w;
let heading, attitude, bank;
let test = x * y + z * w;
if (test > 0.499) { // singularity at north pole
if (test > 0.499999) { // singularity at north pole
heading = 2 * Math.atan2(x,w);
attitude = Math.PI/2;
bank = 0;
}
if (test < -0.499) { // singularity at south pole
if (test < -0.499999) { // singularity at south pole
heading = -2 * Math.atan2(x,w);
attitude = - Math.PI/2;
bank = 0;
-12
View File
@@ -1,12 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
// common module
// constant value
#define PI 3.14159265359
#define PI2 6.28318530718
#define EPSILON 1e-6
#define LOG2 1.442695
// common function
#define saturate(a) clamp( a, 0.0, 1.0 )
@@ -1,45 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
// sRGB-linear transform approximation
// http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html
vec3 gammaToLinearSpaceRGB(vec3 sRGB) { // TODO: use half maybe better.
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
}
vec3 linearToGammaSpaceRGB(vec3 RGB) { // TODO: use half maybe better.
vec3 S1 = sqrt(RGB);
vec3 S2 = sqrt(S1);
vec3 S3 = sqrt(S2);
return 0.585122381 * S1 + 0.783140355 * S2 - 0.368262736 * S3;
}
vec4 gammaToLinearSpaceRGBA(vec4 sRGBA) {
return vec4(gammaToLinearSpaceRGB(sRGBA.rgb), sRGBA.a);
}
vec4 linearToGammaSpaceRGBA(vec4 RGBA) {
return vec4(linearToGammaSpaceRGB(RGBA.rgb), RGBA.a);
}
// exact version
float gammaToLinearSpaceExact(float val) {
if (val <= 0.04045) {
return val / 12.92;
} else if (val < 1.0) {
return pow((val + 0.055) / 1.055, 2.4);
} else {
return pow(val, 2.2);
}
}
float linearToGammaSpaceExact(float val) {
if (val <= 0.0) {
return 0.0;
} else if (val <= 0.0031308) {
return 12.92 * val;
} else if (val < 1.0) {
return 1.055 * pow(val, 0.4166667) - 0.055;
} else {
return pow(val, 0.45454545);
}
}
-12
View File
@@ -1,12 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
vec4 packDepthToRGBA(float depth) {
vec4 ret = vec4(1.0, 255.0, 65025.0, 160581375.0) * depth;
ret = fract(ret);
ret -= ret.yzww * vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);
return ret;
}
float unpackRGBAToDepth(vec4 color) {
return dot(color, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 160581375.0));
}
@@ -1,65 +0,0 @@
uniform vec2 frameTile;
uniform vec2 mainTiling;
uniform vec2 mainOffset;
uniform mat4 model;
uniform mat4 viewProj;
uniform mat4 view;
#if USE_STRETCHED_BILLBOARD
uniform vec3 eye;
uniform float velocityScale;
uniform float lengthScale;
#endif
varying vec2 uv;
varying vec4 color;
void computeVertPos(inout vec4 pos, vec2 vertOffset
#if USE_BILLBOARD || USE_VERTICAL_BILLBOARD
, mat4 view
#endif
#if USE_STRETCHED_BILLBOARD
, vec3 eye
, vec4 velocity
, float velocityScale
, float lengthScale
, float size
, float xIndex
#endif
) {
#if USE_BILLBOARD
vec3 camRight = normalize(vec3(view[0][0], view[1][0], view[2][0]));
vec3 camUp = normalize(vec3(view[0][1], view[1][1], view[2][1]));
pos.xyz += (camRight * vertOffset.x) + (camUp * vertOffset.y);
#elif USE_STRETCHED_BILLBOARD
vec3 camRight = normalize(cross(pos.xyz - eye, velocity.xyz));
vec3 camUp = velocity.xyz * velocityScale + normalize(velocity.xyz) * lengthScale * size;
pos.xyz += (camRight * abs(vertOffset.x) * sign(vertOffset.y)) - camUp * xIndex;
#elif USE_HORIZONTAL_BILLBOARD
vec3 camRight = vec3(1, 0, 0);
vec3 camUp = vec3(0, 0, -1);
pos.xyz += (camRight * vertOffset.x) + (camUp * vertOffset.y);
#elif USE_VERTICAL_BILLBOARD
vec3 camRight = normalize(vec3(view[0][0], view[1][0], view[2][0]));
vec3 camUp = vec3(0, 1, 0);
pos.xyz += (camRight * vertOffset.x) + (camUp * vertOffset.y);
#else
pos.x += vertOffset.x;
pos.y += vertOffset.y;
#endif
}
vec2 computeUV(float frameIndex, vec2 vertIndex, vec2 frameTile) {
vec2 aniUV = vec2(0, floor(frameIndex * frameTile.y));
aniUV.x = floor(frameIndex * frameTile.x * frameTile.y - aniUV.y * frameTile.x);
aniUV.y = frameTile.y - aniUV.y - 1.0;
return (aniUV.xy + vertIndex) / vec2(frameTile.x, frameTile.y);
}
void rotateCorner(inout vec2 corner, float angle) {
float xOS = cos(angle) * corner.x - sin(angle) * corner.y;
float yOS = sin(angle) * corner.x + cos(angle) * corner.y;
corner.x = xOS;
corner.y = yOS;
}
@@ -1,377 +0,0 @@
#include <particle-common>
#define MAX_KEY_NUM 8
#define CURVE_MODE_CONSTANT 0
#define CURVE_MODE_RANDOM_CONSTANT 1
#define CURVE_MODE_CURVE 2
#define CURVE_MODE_RANDOM_CURVE 3
#define GRADIENT_MODE_FIX 0
#define GRADIENT_MODE_BLEND 1
#define GRADIENT_RANGE_MODE_COLOR 0
#define GRADIENT_RANGE_MODE_TWO_COLOR 1
#define GRADIENT_RANGE_MODE_RANDOM_COLOR 2
#define GRADIENT_RANGE_MODE_GRADIENT 3
#define GRADIENT_RANGE_MODE_TWO_GRADIENT 4
#define SIMULATE_SPACE_LOCAL 0
#define SIMULATE_SPACE_WORLD 1
#define ANIMATION_MODE_WHOLE_SHEET 0
#define ANIMATION_MODE_SINGLE_ROW 1
#define COLOR_OVERTIME_RAND_OFFSET 91041.
#define FORCE_OVERTIME_RAND_OFFSET 212165.
#define ROTATION_OVERTIME_RAND_OFFSET 125292.
#define SIZE_OVERTIME_RAND_OFFSET 39825.
#define TEXTURE_ANIMATION_RAND_OFFSET 90794.
#define VELOCITY_OVERTIME_RAND_OFFSET 197866.
#define DECL_CURVE_STRUCT(name) \
uniform int u_##name##_curveMode; \
uniform float u_##name##_minConstant; \
uniform float u_##name##_maxConstant; \
uniform vec4 u_##name##_minKeyCoef[MAX_KEY_NUM]; \
uniform float u_##name##_minKeyTime[MAX_KEY_NUM]; \
uniform vec4 u_##name##_maxKeyCoef[MAX_KEY_NUM]; \
uniform float u_##name##_maxKeyTime[MAX_KEY_NUM];
#define DECL_CURVE_STRUCT_INT(name) \
DECL_CURVE_STRUCT(name) \
uniform float u_##name##_minIntegral[MAX_KEY_NUM - 1]; \
uniform float u_##name##_maxIntegral[MAX_KEY_NUM - 1];
#define DECL_GRADIENT_STRUCT(name) \
uniform int u_##name##_rangeMode; \
uniform vec4 u_##name##_minColor; \
uniform vec4 u_##name##_maxColor; \
uniform int u_##name##_minGradMode; \
uniform vec3 u_##name##_minColorKeyValue[MAX_KEY_NUM]; \
uniform float u_##name##_minColorKeyTime[MAX_KEY_NUM]; \
uniform float u_##name##_minAlphaKeyValue[MAX_KEY_NUM]; \
uniform float u_##name##_minAlphaKeyTime[MAX_KEY_NUM]; \
uniform int u_##name##_maxGradMode; \
uniform vec3 u_##name##_maxColorKeyValue[MAX_KEY_NUM]; \
uniform float u_##name##_maxColorKeyTime[MAX_KEY_NUM]; \
uniform float u_##name##_maxAlphaKeyValue[MAX_KEY_NUM]; \
uniform float u_##name##_maxAlphaKeyTime[MAX_KEY_NUM];
#define EVAL_CURVE_RANGE(name, t, rnd) \
evaluateCurveRange(u_##name##_curveMode, u_##name##_minConstant, u_##name##_maxConstant, u_##name##_minKeyTime, u_##name##_minKeyCoef, u_##name##_maxKeyTime, u_##name##_maxKeyCoef, t, rnd)
#define EVAL_CURVE_INTEGRAL(name, t, ts, rnd) \
evaluateCurveRangeIntegral(u_##name##_curveMode, u_##name##_minConstant, u_##name##_maxConstant, u_##name##_minKeyTime, u_##name##_minKeyCoef, u_##name##_minIntegral, u_##name##_maxKeyTime, u_##name##_maxKeyCoef, u_##name##_maxIntegral, t, ts, rnd)
#define EVAL_CURVE_INTEGRAL_TWICE(name, t, ts, rnd) \
evaluateCurveRangeIntegralTwice(u_##name##_curveMode, u_##name##_minConstant, u_##name##_maxConstant, u_##name##_minKeyTime, u_##name##_minKeyCoef, u_##name##_minIntegral, u_##name##_maxKeyTime, u_##name##_maxKeyCoef, u_##name##_maxIntegral, t, ts, rnd)
#define EVAL_GRADIENT_RANGE(name, t, rnd) \
evaluateGradientRange(u_##name##_rangeMode, u_##name##_minColor, u_##name##_maxColor, \
u_##name##_minGradMode, u_##name##_minColorKeyValue, u_##name##_minColorKeyTime, u_##name##_minAlphaKeyValue, u_##name##_minAlphaKeyTime, \
u_##name##_maxGradMode, u_##name##_maxColorKeyValue, u_##name##_maxColorKeyTime, u_##name##_maxAlphaKeyValue, u_##name##_maxAlphaKeyTime, t, rnd);
attribute vec4 a_position_starttime; // center position,particle start time
attribute vec4 a_vertIdx_size_angle; // xy:vertex index,z:size,w:angle
attribute vec4 a_color;
attribute vec4 a_dir_life; // xyz:particle start velocity,w:particle lifetime
attribute float a_rndSeed;
uniform float u_psTime;
uniform vec4 u_worldRot;
#if VELOCITY_OVERTIME_MODULE_ENABLE
uniform int u_velocity_space;
uniform float u_speedModifier;
DECL_CURVE_STRUCT_INT(velocity_pos_x)
DECL_CURVE_STRUCT_INT(velocity_pos_y)
DECL_CURVE_STRUCT_INT(velocity_pos_z)
#if USE_STRETCHED_BILLBOARD
DECL_CURVE_STRUCT(velocity_x)
DECL_CURVE_STRUCT(velocity_y)
DECL_CURVE_STRUCT(velocity_z)
#endif
#endif
#if FORCE_OVERTIME_MODULE_ENABLE
uniform int u_force_space;
DECL_CURVE_STRUCT_INT(force_pos_x)
DECL_CURVE_STRUCT_INT(force_pos_y)
DECL_CURVE_STRUCT_INT(force_pos_z)
#if USE_STRETCHED_BILLBOARD
DECL_CURVE_STRUCT_INT(force_vel_x)
DECL_CURVE_STRUCT_INT(force_vel_y)
DECL_CURVE_STRUCT_INT(force_vel_z)
#endif
#endif
#if SIZE_OVERTIME_MODULE_ENABLE
DECL_CURVE_STRUCT(size)
#endif
#if COLOR_OVERTIME_MODULE_ENABLE
DECL_GRADIENT_STRUCT(color)
#endif
#if TEXTURE_ANIMATION_ENABLE
DECL_CURVE_STRUCT(frameOverTime)
uniform float u_cycles;
uniform int u_animation_mode;
uniform bool u_random_row;
uniform int u_row_index;
#endif
#if ROTATE_OVERTIME_MODULE_ENABLE
DECL_CURVE_STRUCT_INT(rotate)
#endif
float repeat(float t, float length) {
return t - floor(t / length) * length;
}
vec4 rotateQuat(vec4 p, vec4 q) {
vec3 iv = cross(q.xyz, p.xyz) + q.w * p.xyz;
vec3 res = p.xyz + 2.0 * cross(q.xyz, iv);
return vec4(res.xyz, p.w);
}
float random(float seed) {
seed = mod(seed, 233280.);
float q = (seed * 9301. + 49297.) / 233280.;
return fract(q);
}
float calcCurveValue(vec4 coef, float t) {
return t * (t * (t * coef.x + coef.y) + coef.z) + coef.w;
}
float evaluateCurve(float keyTime[MAX_KEY_NUM], vec4 keyCoef[MAX_KEY_NUM], float normalizedTime) {
for (int i = 0; i < MAX_KEY_NUM; i++) {
if (keyTime[i] > normalizedTime) {
return calcCurveValue(keyCoef[i], normalizedTime - (i == 0 ? 0. : keyTime[i - 1]));
}
}
}
float evaluateIntegral(float keyTime[MAX_KEY_NUM], vec4 keyCoef[MAX_KEY_NUM], float integral[MAX_KEY_NUM - 1], float normalizedTime, float ts) {
for (int i = 0; i < MAX_KEY_NUM; i++) {
if (keyTime[i] > normalizedTime) {
float t = normalizedTime - (i == 0 ? 0. : keyTime[i - 1]);
return ts * ((i - 1 < 0 ? 0. : integral[i - 1]) + t * calcCurveValue(keyCoef[i], t));
}
}
}
float evaluateIntegralTwice(float keyTime[MAX_KEY_NUM], vec4 keyCoef[MAX_KEY_NUM], float integral[MAX_KEY_NUM - 1], float normalizedTime, float ts) {
for (int i = 0; i < MAX_KEY_NUM; i++) {
if (keyTime[i] > normalizedTime) {
float t = normalizedTime - (i == 0 ? 0. : keyTime[i - 1]);
return ts * ts * ((i - 1 < 0 ? 0. : integral[i - 1]) + t * t * calcCurveValue(keyCoef[i], t));
}
}
}
float evaluateCurveRange(int mode, float minConstant, float maxConstant
, float minKeyTime[MAX_KEY_NUM], vec4 minKeyCoef[MAX_KEY_NUM]
, float maxKeyTime[MAX_KEY_NUM], vec4 maxKeyCoef[MAX_KEY_NUM]
, float t, float rnd) {
if (mode == CURVE_MODE_CONSTANT) {
return minConstant;
} else if (mode == CURVE_MODE_RANDOM_CONSTANT) {
return mix(minConstant, maxConstant, random(rnd));
} else if (mode == CURVE_MODE_CURVE) {
return evaluateCurve(minKeyTime, minKeyCoef, t);
} else if (mode == CURVE_MODE_RANDOM_CURVE) {
return mix(evaluateCurve(minKeyTime, minKeyCoef, t), evaluateCurve(maxKeyTime, maxKeyCoef, t), random(rnd));
}
}
float evaluateCurveRangeIntegral(int mode, float minConstant, float maxConstant
, float minKeyTime[MAX_KEY_NUM], vec4 minKeyCoef[MAX_KEY_NUM], float minIntegral[MAX_KEY_NUM - 1]
, float maxKeyTime[MAX_KEY_NUM], vec4 maxKeyCoef[MAX_KEY_NUM], float maxIntegral[MAX_KEY_NUM - 1]
, float t, float ts, float rnd) {
if (mode == CURVE_MODE_CONSTANT) {
return minConstant * t * ts;
} else if (mode == CURVE_MODE_RANDOM_CONSTANT) {
return mix(minConstant, maxConstant, random(rnd)) * t * ts;
} else if (mode == CURVE_MODE_CURVE) {
return evaluateIntegral(minKeyTime, minKeyCoef, minIntegral, t, ts);
} else if (mode == CURVE_MODE_RANDOM_CURVE) {
return mix(evaluateIntegral(minKeyTime, minKeyCoef, minIntegral, t, ts), evaluateIntegral(maxKeyTime, maxKeyCoef, maxIntegral, t, ts), random(rnd));
}
}
float evaluateCurveRangeIntegralTwice(int mode, float minConstant, float maxConstant
, float minKeyTime[MAX_KEY_NUM], vec4 minKeyCoef[MAX_KEY_NUM], float minIntegral[MAX_KEY_NUM - 1]
, float maxKeyTime[MAX_KEY_NUM], vec4 maxKeyCoef[MAX_KEY_NUM], float maxIntegral[MAX_KEY_NUM - 1]
, float t, float ts, float rnd) {
if (mode == CURVE_MODE_CONSTANT) {
return minConstant * t * t * ts * ts / 2.;
} else if (mode == CURVE_MODE_RANDOM_CONSTANT) {
return mix(minConstant, maxConstant, random(rnd)) * t * t * ts * ts / 2.;
} else if (mode == CURVE_MODE_CURVE) {
return evaluateIntegralTwice(minKeyTime, minKeyCoef, minIntegral, t, ts);
} else if (mode == CURVE_MODE_RANDOM_CURVE) {
return mix(evaluateIntegralTwice(minKeyTime, minKeyCoef, minIntegral, t, ts), evaluateIntegralTwice(maxKeyTime, maxKeyCoef, maxIntegral, t, ts), random(rnd));
}
}
vec4 evaluateGradient(int mode, float colorKeyTime[MAX_KEY_NUM], vec3 colorKeyValue[MAX_KEY_NUM]
, float alphaKeyTime[MAX_KEY_NUM], float alphaKeyValue[MAX_KEY_NUM]
, float t){
vec4 ret;
for (int i = 0; i < MAX_KEY_NUM; i++) {
if (t < colorKeyTime[i]) {
if (mode == GRADIENT_MODE_FIX) {
ret.xyz = colorKeyValue[i];
} else if (mode == GRADIENT_MODE_BLEND) {
ret.xyz = mix(colorKeyValue[i - 1], colorKeyValue[i], (t - colorKeyTime[i - 1]) / (colorKeyTime[i] - colorKeyTime[i - 1]));
}
break;
}
}
for (int i = 0; i < MAX_KEY_NUM; i++) {
if (t < alphaKeyTime[i]) {
if (mode == GRADIENT_MODE_FIX) {
ret.w = alphaKeyValue[i];
} else if (mode == GRADIENT_MODE_BLEND) {
ret.w = mix(alphaKeyValue[i - 1], alphaKeyValue[i], (t - alphaKeyTime[i - 1]) / (alphaKeyTime[i] - alphaKeyTime[i - 1]));
}
break;
}
}
return ret;
}
vec4 evaluateGradientRange(int rangeMode, vec4 minColor, vec4 maxColor,
int minGradMode, vec3 minColorKeyValue[MAX_KEY_NUM], float minColorKeyTime[MAX_KEY_NUM], float minAlphaKeyValue[MAX_KEY_NUM], float minAlphaKeyTime[MAX_KEY_NUM],
int maxGradMode, vec3 maxColorKeyValue[MAX_KEY_NUM], float maxColorKeyTime[MAX_KEY_NUM], float maxAlphaKeyValue[MAX_KEY_NUM], float maxAlphaKeyTime[MAX_KEY_NUM],
float t, float rnd){
if (rangeMode == GRADIENT_RANGE_MODE_COLOR) {
return minColor;
} else if (rangeMode == GRADIENT_RANGE_MODE_TWO_COLOR) {
return mix(minColor, maxColor, rnd);
} else if (rangeMode == GRADIENT_RANGE_MODE_GRADIENT) {
return evaluateGradient(minGradMode, minColorKeyTime, minColorKeyValue, minAlphaKeyTime, minAlphaKeyValue, t);
} else if (rangeMode == GRADIENT_RANGE_MODE_TWO_GRADIENT) {
return mix(evaluateGradient(minGradMode, minColorKeyTime, minColorKeyValue, minAlphaKeyTime, minAlphaKeyValue, t),
evaluateGradient(maxGradMode, maxColorKeyTime, maxColorKeyValue, maxAlphaKeyTime, maxAlphaKeyValue, t), rnd);
}
}
void gpvs_main() {
vec4 pos = vec4(a_position_starttime.xyz, 1.);
float activeTime = u_psTime - a_position_starttime.w;
float normalizedTime = activeTime / a_dir_life.w;
#if VELOCITY_OVERTIME_MODULE_ENABLE
float speedModifier = u_speedModifier;
#else
float speedModifier = 1.;
#endif
pos.xyz += a_dir_life.xyz * activeTime * speedModifier;
#if USE_STRETCHED_BILLBOARD
vec4 velocity = vec4(a_dir_life.xyz, 0.);
velocity *= speedModifier;
#endif
#if !USE_WORLD_SPACE
pos = model * pos;
#if USE_STRETCHED_BILLBOARD
velocity = rotateQuat(velocity, u_worldRot);
#endif
#endif
#if VELOCITY_OVERTIME_MODULE_ENABLE
vec4 velocityTrack = vec4(EVAL_CURVE_INTEGRAL(velocity_pos_x, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL(velocity_pos_y, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL(velocity_pos_z, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), 0);
velocityTrack = velocityTrack * speedModifier;
if (u_velocity_space == SIMULATE_SPACE_LOCAL) {
velocityTrack = rotateQuat(velocityTrack, u_worldRot);
}
pos += velocityTrack;
#if USE_STRETCHED_BILLBOARD
vec4 velocityVel = vec4(EVAL_CURVE_RANGE(velocity_x, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), EVAL_CURVE_RANGE(velocity_y, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), EVAL_CURVE_RANGE(velocity_z, normalizedTime, a_dir_life.w, a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET), 0);
if (u_velocity_space == SIMULATE_SPACE_LOCAL) {
velocityVel = rotateQuat(velocityVel, u_worldRot);
}
velocityVel *= speedModifier;
velocity += velocityVel;
#endif
#endif
#if FORCE_OVERTIME_MODULE_ENABLE
vec4 forceTrack = vec4(EVAL_CURVE_INTEGRAL_TWICE(force_pos_x, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL_TWICE(force_pos_y, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL_TWICE(force_pos_z, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), 0);
forceTrack = forceTrack * speedModifier;
if (u_force_space == SIMULATE_SPACE_LOCAL) {
forceTrack = rotateQuat(forceTrack, u_worldRot);
}
pos += forceTrack;
#if USE_STRETCHED_BILLBOARD
vec4 forceVel = vec4(EVAL_CURVE_INTEGRAL(force_vel_x, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL(force_vel_y, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), EVAL_CURVE_INTEGRAL(force_vel_z, normalizedTime, a_dir_life.w, a_rndSeed + FORCE_OVERTIME_RAND_OFFSET), 0);
if (u_force_space == SIMULATE_SPACE_LOCAL) {
forceVel = rotateQuat(forceVel, u_worldRot);
}
forceVel *= speedModifier;
velocity += forceVel;
#endif
#endif
float size = a_vertIdx_size_angle.z;
#if SIZE_OVERTIME_MODULE_ENABLE
float sizeModifier = EVAL_CURVE_RANGE(size, normalizedTime, a_rndSeed + SIZE_OVERTIME_RAND_OFFSET);
size *= sizeModifier;
#endif
vec2 cornerOffset = vec2((a_vertIdx_size_angle.xy - 0.5) * size);
#if !USE_STRETCHED_BILLBOARD
float angle = a_vertIdx_size_angle.w;
#if ROTATE_OVERTIME_MODULE_ENABLE
angle += EVAL_CURVE_INTEGRAL(rotate, normalizedTime, a_dir_life.w, a_rndSeed + ROTATION_OVERTIME_RAND_OFFSET);
#endif
rotateCorner(cornerOffset, angle);
#endif
computeVertPos(pos, cornerOffset
#if USE_BILLBOARD || USE_VERTICAL_BILLBOARD
, view
#endif
#if USE_STRETCHED_BILLBOARD
, eye
, velocity
, velocityScale
, lengthScale
, size
, a_vertIdx_size_angle.x
#endif
);
pos = viewProj * pos;
float frameIndex = 0.;
#if TEXTURE_ANIMATION_ENABLE
if (u_animation_mode == ANIMATION_MODE_WHOLE_SHEET) {
frameIndex = repeat(u_cycles * EVAL_CURVE_RANGE(frameOverTime, normalizedTime, a_rndSeed + TEXTURE_ANIMATION_RAND_OFFSET), 1.);
} else if (u_animation_mode == ANIMATION_MODE_SINGLE_ROW) {
float rowLength = 1. / frameTile.y;
if (u_random_row) {
float f = repeat(u_cycles * EVAL_CURVE_RANGE(frameOverTime, normalizedTime, a_rndSeed + TEXTURE_ANIMATION_RAND_OFFSET), 1.);
float startRow = floor(random(floor(u_psTime * 1000.)) * frameTile.y);
float from = startRow * rowLength;
float to = from + rowLength;
frameIndex = mix(from, to, f);
}
else {
float from = float(u_row_index) * rowLength;
float to = from + rowLength;
frameIndex = mix(from, to, repeat(u_cycles * EVAL_CURVE_RANGE(frameOverTime, normalizedTime, a_rndSeed + TEXTURE_ANIMATION_RAND_OFFSET), 1.));
}
}
#endif
uv = computeUV(frameIndex, a_vertIdx_size_angle.xy, frameTile) * mainTiling + mainOffset;
#if COLOR_OVERTIME_MODULE_ENABLE
color = a_color * EVAL_GRADIENT_RANGE(color, normalizedTime, a_rndSeed + COLOR_OVERTIME_RAND_OFFSET);
#else
color = a_color;
#endif
gl_Position = pos;
}
@@ -1,55 +0,0 @@
#include <particle-common>
attribute vec3 a_position; // center position
attribute vec3 a_uv; // xy:vertex index,z:frame index
attribute vec2 a_uv0; // size, angle
attribute vec4 a_color;
#if USE_STRETCHED_BILLBOARD
attribute vec3 a_color0; // velocity.x, velocity.y, velocity.z, scale
#endif
void lpvs_main() {
vec4 pos = vec4(a_position, 1);
#if USE_STRETCHED_BILLBOARD
vec4 velocity = vec4(a_color0.xyz, 0);
#endif
#if !USE_WORLD_SPACE
// // simulate in world space. apply model matrix on CPU side.
// #else
pos = model * pos;
#if USE_STRETCHED_BILLBOARD
velocity = model * velocity;
#endif
#endif
vec2 cornerOffset = vec2((a_uv.xy - 0.5) * a_uv0.x);
#if !USE_STRETCHED_BILLBOARD
// // rotation will not be applied in stretchedBillboard mode(Unity).
// #else
// rotation
rotateCorner(cornerOffset, a_uv0.y);
#endif
computeVertPos(pos, cornerOffset
#if USE_BILLBOARD || USE_VERTICAL_BILLBOARD
, view
#endif
#if USE_STRETCHED_BILLBOARD
, eye
, velocity
, velocityScale
, lengthScale
, a_uv0.x
, a_uv.x
#endif
);
pos = viewProj * pos;
uv = computeUV(a_uv.z, a_uv.xy, frameTile) * mainTiling + mainOffset;
color = a_color;
gl_Position = pos;
}
-373
View File
@@ -1,373 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
#if USE_NORMAL_TEXTURE
#extension GL_OES_standard_derivatives : enable
#endif
#if USE_TEX_LOD
#extension GL_EXT_shader_texture_lod: enable
#endif
#include <common>
#include <gamma-correction>
struct LightInfo {
vec3 lightDir;
vec3 radiance;
};
#if NUM_DIR_LIGHTS > 0
#pragma for id in range(0, NUM_DIR_LIGHTS)
uniform vec3 dir_light{id}_direction;
uniform vec3 dir_light{id}_color;
#pragma endFor
#endif
#if NUM_POINT_LIGHTS > 0
#pragma for id in range(0, NUM_POINT_LIGHTS)
uniform vec3 point_light{id}_position;
uniform vec3 point_light{id}_color;
uniform float point_light{id}_range;
#pragma endFor
#endif
#if NUM_SPOT_LIGHTS > 0
#pragma for id in range(0, NUM_SPOT_LIGHTS)
uniform vec3 spot_light{id}_position;
uniform vec3 spot_light{id}_direction;
uniform vec3 spot_light{id}_color;
uniform vec2 spot_light{id}_spot;
uniform float spot_light{id}_range;
#pragma endFor
#endif
// directional light
LightInfo computeDirectionalLighting(
vec3 lightDirection,
vec3 lightColor
) {
LightInfo ret;
ret.lightDir = -normalize(lightDirection);
ret.radiance = lightColor;
return ret;
}
// point light
LightInfo computePointLighting(
vec3 lightPosition,
vec3 positionW,
vec3 lightColor,
float lightRange
) {
LightInfo ret;
vec3 lightDir = lightPosition - positionW;
float attenuation = max(0.0, 1.0 - length(lightDir) / lightRange);
ret.lightDir = normalize(lightDir);
ret.radiance = lightColor * attenuation;
return ret;
}
// spot light
LightInfo computeSpotLighting(
vec3 lightPosition,
vec3 positionW,
vec3 lightDirection,
vec3 lightColor,
vec2 lightSpot,
float lightRange
) {
LightInfo ret;
vec3 lightDir = lightPosition - positionW;
float attenuation = max(0., 1.0 - length(lightDir) / lightRange);
float cosConeAngle = max(0., dot(lightDirection, -lightDir));
cosConeAngle = cosConeAngle < lightSpot.x ? 0.0 : cosConeAngle;
cosConeAngle = pow(cosConeAngle,lightSpot.y);
ret.lightDir = normalize(lightDir);
ret.radiance = lightColor * attenuation * cosConeAngle;
return ret;
}
#include <unpack>
#if USE_SHADOW_MAP
#include <packing>
#include <shadow-mapping>
#endif
uniform vec3 eye;
varying vec3 pos_w;
varying vec3 normal_w;
#if USE_ALBEDO_TEXTURE || USE_NORMAL_TEXTURE || USE_MRA_TEXTURE || USE_METALLIC_TEXTURE || USE_ROUGHNESS_TEXTURE || USE_AO_TEXTURE || USE_EMISSIVE_TEXTURE
varying vec2 uv0;
#endif
#if USE_IBL
uniform samplerCube diffuseEnvTexture;
uniform samplerCube specularEnvTexture;
uniform sampler2D brdfLUT;
#if USE_TEX_LOD
uniform float maxReflectionLod;
#endif
#endif
// material parameters
uniform vec4 albedo;
#if USE_ALBEDO_TEXTURE
uniform sampler2D albedo_texture;
#endif
#if USE_MRA_TEXTURE
uniform sampler2D mra_texture;
#endif
uniform float metallic;
#if USE_METALLIC_TEXTURE
uniform sampler2D metallic_texture;
#endif
uniform float roughness;
#if USE_ROUGHNESS_TEXTURE
uniform sampler2D roughness_texture;
#endif
uniform float ao;
#if USE_AO_TEXTURE
uniform sampler2D ao_texture;
#endif
#if USE_EMISSIVE
uniform vec3 emissive;
#if USE_EMISSIVE_TEXTURE
uniform sampler2D emissive_texture;
#endif
#endif
#if USE_ALPHA_TEST
uniform float alphaTestThreshold;
#endif
#if USE_NORMAL_TEXTURE
uniform sampler2D normal_texture;
// get world-space normal from normal texture
vec3 getNormalFromTexture() {
vec3 tangentNormal = texture2D(normal_texture, uv0).rgb * 2.0 - 1.0;
vec3 q1 = dFdx(pos_w);
vec3 q2 = dFdy(pos_w);
vec2 st1 = dFdx(uv0);
vec2 st2 = dFdy(uv0);
vec3 N = normalize(normal_w);
vec3 T = normalize(q1*st2.t - q2*st1.t);
vec3 B = -normalize(cross(N, T));
mat3 TBN = mat3(T, B, N);
return normalize(TBN * tangentNormal);
}
#endif
// Cook-Torrance BRDF model
// D() Normal distribution function (Trowbridge-Reitz GGX)
// https://disney-animation.s3.amazonaws.com/library/s2012_pbs_disney_brdf_notes_v2.pdf
float distributionGGX(vec3 N, vec3 H, float roughness) {
float a = roughness * roughness;
float a2 = a * a;
float NdotH = max(dot(N, H), 0.0);
float NdotH2 = NdotH * NdotH;
float nom = a2;
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
denom = PI * denom * denom;
return nom / denom;
}
// G() Geometry function (Smith's Schlick GGX)
// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
float geometrySchlickGGX(float NdotV, float roughness) {
float r = (roughness + 1.0);
float k = (r * r) / 8.0;
float nom = NdotV;
float denom = NdotV * (1.0 - k) + k;
return nom / denom;
}
float geometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
float NdotV = max(dot(N, V), 0.0);
float NdotL = max(dot(N, L), 0.0);
float ggx2 = geometrySchlickGGX(NdotV, roughness);
float ggx1 = geometrySchlickGGX(NdotL, roughness);
return ggx1 * ggx2;
}
// F() Fresnel equation (Fresnel-Schlick approximation)
// Optimized variant (presented by Epic at SIGGRAPH '13)
// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
vec3 fresnelSchlick(float cosTheta, vec3 F0) {
float fresnel = exp2((-5.55473 * cosTheta - 6.98316) * cosTheta);
return F0 + (1.0 - F0) * fresnel;
}
vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness) {
float fresnel = exp2((-5.55473 * cosTheta - 6.98316) * cosTheta);
return F0 + (max(vec3(1.0 - roughness), F0) - F0) * fresnel;
}
// BRDF equation
vec3 brdf(LightInfo lightInfo, vec3 N, vec3 V, vec3 F0, vec3 albedo, float metallic, float roughness) {
vec3 H = normalize(V + lightInfo.lightDir);
float NDF = distributionGGX(N, H, roughness);
float G = geometrySmith(N, V, lightInfo.lightDir, roughness);
vec3 F = fresnelSchlick(max(dot(H, V), 0.0), F0);
vec3 nominator = NDF * G * F;
float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, lightInfo.lightDir), 0.0) + 0.001; // 0.001 to prevent divide by zero.
vec3 specular = nominator / denominator;
// kS is equal to Fresnel
vec3 kS = F;
// for energy conservation, the diffuse and specular light can't
// be above 1.0 (unless the surface emits light); to preserve this
// relationship the diffuse component (kD) should equal 1.0 - kS.
vec3 kD = vec3(1.0) - kS;
// multiply kD by the inverse metalness such that only non-metals
// have diffuse lighting, or a linear blend if partly metal (pure metals
// have no diffuse light).
kD *= 1.0 - metallic;
float NdotL = max(dot(N, lightInfo.lightDir), 0.0);
return (kD * albedo / PI + specular) * lightInfo.radiance * NdotL;
}
vec4 frag() {
float opacity = 1.0;
#if USE_ALBEDO_TEXTURE
vec4 baseColor = albedo * gammaToLinearSpaceRGBA(texture2D(albedo_texture, uv0));
vec3 albedo = baseColor.rgb;
opacity = baseColor.a;
#else
opacity = albedo.a;
vec3 albedo = albedo.rgb;
#endif
#if USE_ALPHA_TEST
if(opacity < alphaTestThreshold) discard;
#endif
#if USE_MRA_TEXTURE
vec3 metalRoughness = texture2D(mra_texture, uv0).rgb;
float metallic = metalRoughness.r;
float roughness = metalRoughness.g;
float ao = metalRoughness.b;
#else
#if USE_METALLIC_TEXTURE
float metallic = texture2D(metallic_texture, uv0).r;
#endif
#if USE_ROUGHNESS_TEXTURE
float roughness = texture2D(roughness_texture, uv0).r;
#endif
#if USE_AO_TEXTURE
float ao = texture2D(ao_texture, uv0).r;
#endif
#endif
vec3 N = normalize(normal_w);
#if USE_NORMAL_TEXTURE
N = getNormalFromTexture();
#endif
vec3 V = normalize(eye - pos_w);
// calculate reflectance at normal incidence; if dia-electric (like plastic) use F0
// of 0.04 and if it's a metal, use the albedo color as F0 (metallic workflow)
vec3 F0 = vec3(0.04);
F0 = mix(F0, albedo, metallic);
// reflection
vec3 Lo = vec3(0.0);
// point light (a 'for' loop to accumulate all light sources)
#if NUM_POINT_LIGHTS > 0
#pragma for id in range(0, NUM_POINT_LIGHTS)
LightInfo pointLight{id};
pointLight{id} = computePointLighting(point_light{id}_position, pos_w, point_light{id}_color, point_light{id}_range);
Lo += brdf(pointLight{id}, N, V, F0, albedo, metallic, roughness);
#pragma endFor
#endif
#if NUM_DIR_LIGHTS > 0
#pragma for id in range(0, NUM_DIR_LIGHTS)
LightInfo directionalLight{id};
directionalLight{id} = computeDirectionalLighting(dir_light{id}_direction, dir_light{id}_color);
Lo += brdf(directionalLight{id}, N, V, F0, albedo, metallic, roughness);
#pragma endFor
#endif
#if NUM_SPOT_LIGHTS > 0
#pragma for id in range(0, NUM_SPOT_LIGHTS)
LightInfo spotLight{id};
spotLight{id} = computeSpotLighting(spot_light{id}_position, pos_w, spot_light{id}_direction, spot_light{id}_color, spot_light{id}_spot, spot_light{id}_range);
Lo += brdf(spotLight{id}, N, V, F0, albedo, metallic, roughness);
#pragma endFor
#endif
#if USE_EMISSIVE
vec3 emissiveColor = emissive;
#if USE_EMISSIVE_TEXTURE
emissiveColor *= gammaToLinearSpaceRGB(texture2D(emissive_texture, uv0).rgb);
#endif
Lo += emissiveColor;
#endif
// ambient lighting, will be replaced by IBL if IBL used.
vec3 ambient = vec3(0.03) * albedo * ao;
#if USE_IBL
// generate ambient when using IBL.
vec3 F = fresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness);
vec3 kS = F;
vec3 kD = vec3(1.0) - kS;
kD *= 1.0 - metallic;
#if USE_RGBE_IBL_DIFFUSE
vec3 diffuseEnv = unpackRGBE(textureCube(diffuseEnvTexture, N));
#else
vec3 diffuseEnv = textureCube(diffuseEnvTexture, N).rgb;
#endif
vec3 diffuse = diffuseEnv * albedo;
// sample both the specularEnvTexture and the BRDF lut and combine them together as per the Split-Sum approximation to get the IBL specular part.
vec3 R = reflect(-V, N);
#if USE_TEX_LOD
#if USE_RGBE_IBL_SPECULAR
vec3 specularEnv = unpackRGBE(textureCubeLodEXT(specularEnvTexture, R, roughness * maxReflectionLod));
#else
vec3 specularEnv = textureCubeLodEXT(specularEnvTexture, R, roughness * maxReflectionLod).rgb;
#endif
#else
#if USE_RGBE_IBL_SPECULAR
vec3 specularEnv = unpackRGBE(textureCube(specularEnvTexture, R));
#else
vec3 specularEnv = textureCube(specularEnvTexture, R).rgb;
#endif
#endif
vec2 brdf = texture2D(brdfLUT, vec2(max(dot(N, V), 0.0), 1.0 - roughness)).rg;
vec3 specular = specularEnv * (F * brdf.x + brdf.y);
ambient = (kD * diffuse + specular) * ao;
#endif
#if USE_SHADOW_MAP
float shadow = 1.0;
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
shadow *= computeShadowESM(shadowMap_{id}, pos_lightspace_{id}, vDepth_{id}, depthScale_{id}, darkness_{id}, frustumEdgeFalloff_{id});
#pragma endFor
#endif
vec3 color = (ambient + Lo) * shadow;
#else
vec3 color = ambient + Lo;
#endif
// HDR tone mapping.
color = color / (color + vec3(1.0));
// gamma correction.
vec4 finalColor = vec4(color, opacity);
return linearToGammaSpaceRGBA(finalColor);
}
-67
View File
@@ -1,67 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec3 a_position;
attribute vec3 a_normal;
varying vec3 pos_w;
varying vec3 normal_w;
uniform mat4 model;
uniform mat4 viewProj;
uniform mat3 normalMatrix;
#if USE_ALBEDO_TEXTURE || USE_NORMAL_TEXTURE || USE_MRA_TEXTURE || USE_METALLIC_TEXTURE || USE_ROUGHNESS_TEXTURE || USE_AO_TEXTURE || USE_MRA_TEXTURE || USE_EMISSIVE_TEXTURE
attribute vec2 a_uv0;
uniform vec2 mainTiling;
uniform vec2 mainOffset;
varying vec2 uv0;
#endif
#if USE_SKINNING
#include <skinning>
#endif
#if USE_SHADOW_MAP
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
uniform mat4 lightViewProjMatrix_{id};
uniform float minDepth_{id};
uniform float maxDepth_{id};
varying vec4 pos_lightspace_{id};
varying float vDepth_{id};
#pragma endFor
#endif
#endif
vec4 vert () {
vec4 pos = vec4(a_position, 1);
#if USE_SKINNING
mat4 skinMat = skinMatrix();
pos = skinMat * pos;
#endif
pos_w = (model * pos).xyz;
pos = viewProj * model * pos;
#if USE_ALBEDO_TEXTURE || USE_NORMAL_TEXTURE || USE_MRA_TEXTURE || USE_METALLIC_TEXTURE || USE_ROUGHNESS_TEXTURE || USE_AO_TEXTURE || USE_MRA_TEXTURE || USE_EMISSIVE_TEXTURE
uv0 = a_uv0 * mainTiling + mainOffset;
#endif
vec4 normal = vec4(a_normal, 0);
#if USE_SKINNING
normal = skinMat * normal;
#endif
normal_w = normalMatrix * normal.xyz;
#if USE_SHADOW_MAP
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
pos_lightspace_{id} = lightViewProjMatrix_{id} * vec4(pos_w, 1.0);
vDepth_{id} = (pos_lightspace_{id}.z + minDepth_{id}) / (minDepth_{id} + maxDepth_{id});
#pragma endFor
#endif
#endif
return pos;
}
-311
View File
@@ -1,311 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
#if USE_NORMAL_TEXTURE
#extension GL_OES_standard_derivatives : enable
#endif
#include <common>
#include <gamma-correction>
struct LightInfo {
vec3 diffuse;
vec3 specular;
};
LightInfo computeDirectionalLighting(
vec3 lightDirection,
vec3 lightColor,
vec3 normal,
vec3 viewDirection,
float glossiness
) {
LightInfo lightingResult;
float ndl = 0.0;
float ndh = 0.0;
vec3 lightDir = -normalize(lightDirection);
ndl = max(0.0, dot(normal, lightDir));
lightingResult.diffuse = lightColor * ndl;
vec3 dirH = normalize(viewDirection + lightDir);
ndh = max(0.0, dot(normal, dirH));
ndh = (ndl == 0.0) ? 0.0: ndh;
ndh = pow(ndh, max(1.0, glossiness * 128.0));
lightingResult.specular = lightColor * ndh;
return lightingResult;
}
LightInfo computePointLighting(
vec3 lightPosition,
vec3 lightColor,
float lightRange,
vec3 normal,
vec3 positionW,
vec3 viewDirection,
float glossiness
) {
LightInfo lightingResult;
float ndl = 0.0;
float ndh = 0.0;
vec3 lightDir = vec3(0, 0, 0);
float attenuation = 1.0;
lightDir = lightPosition - positionW;
attenuation = max(0., 1.0 - length(lightDir) / lightRange);
lightDir = normalize(lightDir);
ndl = max(0.0, dot(normal, lightDir));
lightingResult.diffuse = lightColor * ndl * attenuation;
vec3 dirH = normalize(viewDirection + lightDir);
ndh = max(0.0, dot(normal, dirH));
ndh = (ndl == 0.0) ? 0.0: ndh;
ndh = pow(ndh, max(1.0, glossiness * 128.0));
lightingResult.specular = lightColor * ndh * attenuation;
return lightingResult;
}
LightInfo computeSpotLighting(
vec3 lightPosition,
vec3 lightDirection,
vec3 lightColor,
float lightRange,
vec2 lightSpot,
vec3 normal,
vec3 positionW,
vec3 viewDirection,
float glossiness
) {
LightInfo lightingResult;
float ndl = 0.0;
float ndh = 0.0;
vec3 lightDir = vec3(0, 0, 0);
float attenuation = 1.0;
float cosConeAngle = 1.0;
lightDir = lightPosition - positionW;
attenuation = max(0., 1.0 - length(lightDir) / lightRange);
lightDir = normalize(lightDir);
cosConeAngle = max(0., dot(lightDirection, -lightDir));
cosConeAngle = cosConeAngle < lightSpot.x ? 0.0 : cosConeAngle;
cosConeAngle = pow(cosConeAngle,lightSpot.y);
ndl = max(0.0, dot(normal, lightDir));
lightingResult.diffuse = lightColor * ndl * attenuation * cosConeAngle;
vec3 dirH = normalize(viewDirection + lightDir);
ndh = max(0.0, dot(normal, dirH));
ndh = (ndl == 0.0) ? 0.0: ndh;
ndh = pow(ndh, max(1.0, glossiness * 128.0));
lightingResult.specular = lightColor * ndh * attenuation * cosConeAngle;
return lightingResult;
}
#if NUM_DIR_LIGHTS > 0
#pragma for id in range(0, NUM_DIR_LIGHTS)
uniform vec3 dir_light{id}_direction;
uniform vec3 dir_light{id}_color;
#pragma endFor
#endif
#if NUM_POINT_LIGHTS > 0
#pragma for id in range(0, NUM_POINT_LIGHTS)
uniform vec3 point_light{id}_position;
uniform vec3 point_light{id}_color;
uniform float point_light{id}_range;
#pragma endFor
#endif
#if NUM_SPOT_LIGHTS > 0
#pragma for id in range(0, NUM_SPOT_LIGHTS)
uniform vec3 spot_light{id}_position;
uniform vec3 spot_light{id}_direction;
uniform vec3 spot_light{id}_color;
uniform float spot_light{id}_range;
uniform vec2 spot_light{id}_spot;
#pragma endFor
#endif
LightInfo getPhongLighting(
vec3 normal,
vec3 positionW,
vec3 viewDirection,
float glossiness
) {
LightInfo result;
result.diffuse = vec3(0, 0, 0);
result.specular = vec3(0, 0, 0);
LightInfo dirLighting;
#if NUM_DIR_LIGHTS > 0
#pragma for id in range(0, NUM_DIR_LIGHTS)
dirLighting = computeDirectionalLighting(dir_light{id}_direction,dir_light{id}_color,normal, viewDirection, glossiness);
result.diffuse += dirLighting.diffuse;
result.specular += dirLighting.specular;
#pragma endFor
#endif
LightInfo pointLighting;
#if NUM_POINT_LIGHTS > 0
#pragma for id in range(0, NUM_POINT_LIGHTS)
pointLighting = computePointLighting(point_light{id}_position, point_light{id}_color, point_light{id}_range,
normal, positionW, viewDirection, glossiness);
result.diffuse += pointLighting.diffuse;
result.specular += pointLighting.specular;
#pragma endFor
#endif
LightInfo spotLighting;
#if NUM_SPOT_LIGHTS > 0
#pragma for id in range(0, NUM_SPOT_LIGHTS)
spotLighting = computeSpotLighting(spot_light{id}_position, spot_light{id}_direction, spot_light{id}_color,
spot_light{id}_range, spot_light{id}_spot,normal, positionW, viewDirection, glossiness);
result.diffuse += spotLighting.diffuse;
result.specular += spotLighting.specular;
#pragma endFor
#endif
return result;
}
#if USE_SHADOW_MAP
#include <packing>
#include <shadow-mapping>
#endif
uniform vec3 eye;
uniform vec3 sceneAmbient;
varying vec3 normal_w;
varying vec3 pos_w;
#if USE_NORMAL_TEXTURE || USE_DIFFUSE_TEXTURE || USE_EMISSIVE_TEXTURE
varying vec2 uv0;
#endif
struct phongMaterial
{
vec3 diffuse;
vec3 emissive;
vec3 specular;
float glossiness;
float opacity;
};
uniform vec4 diffuseColor;
#if USE_DIFFUSE_TEXTURE
uniform sampler2D diffuse_texture;
#endif
#if USE_EMISSIVE
uniform vec3 emissiveColor;
#if USE_EMISSIVE_TEXTURE
uniform sampler2D emissive_texture;
#endif
#endif
#if USE_SPECULAR
uniform vec3 specularColor;
uniform float glossiness;
#if USE_SPECULAR_TEXTURE
uniform sampler2D specular_texture;
#endif
#endif
#if USE_NORMAL_TEXTURE
uniform sampler2D normal_texture;
uniform float normalScale; //this is not used yet
vec3 getNormal(vec3 pos, vec3 normal) {
vec3 q0 = vec3( dFdx( pos.x ), dFdx( pos.y ), dFdx( pos.z ) );
vec3 q1 = vec3( dFdy( pos.x ), dFdy( pos.y ), dFdy( pos.z ) );
vec2 st0 = dFdx( uv0.st );
vec2 st1 = dFdy( uv0.st );
vec3 S = normalize( q0 * st1.t - q1 * st0.t );
vec3 T = normalize( -q0 * st1.s + q1 * st0.s );
vec3 N = normal;
vec3 mapN = texture2D(normal_texture, uv0).rgb * 2.0 - 1.0;
mapN.xy = 1.0 * mapN.xy;
mat3 tsn = mat3( S, T, N );
return normalize( tsn * mapN );
}
#endif
#if USE_ALPHA_TEST
uniform float alphaTestThreshold;
#endif
phongMaterial getPhongMaterial() {
phongMaterial result;
#if USE_DIFFUSE_TEXTURE
vec4 baseColor = diffuseColor * gammaToLinearSpaceRGBA(texture2D(diffuse_texture, uv0));
result.diffuse = baseColor.rgb;
result.opacity = baseColor.a;
#else
result.diffuse = diffuseColor.rgb;
result.opacity = diffuseColor.a;
#endif
#if USE_EMISSIVE
result.emissive = gammaToLinearSpaceRGB(emissiveColor);
#if USE_EMISSIVE_TEXTURE
result.emissive *= gammaToLinearSpaceRGB(texture2D(emissive_texture, uv0).rgb);
#endif
#endif
#if USE_SPECULAR
result.specular = gammaToLinearSpaceRGB(specularColor);
#if USE_SPECULAR_TEXTURE
result.specular = gammaToLinearSpaceRGB(texture2D(specular_texture, uv0).rgb);
#endif
result.glossiness = glossiness;
#endif
return result;
}
vec4 composePhongShading(LightInfo lighting, phongMaterial mtl, float shadow)
{
vec4 o = vec4(0.0, 0.0, 0.0, 1.0);
//diffuse is always calculated
o.xyz = lighting.diffuse * mtl.diffuse;
#if USE_EMISSIVE
o.xyz += mtl.emissive;
#endif
#if USE_SPECULAR
o.xyz += lighting.specular * mtl.specular;
#endif
o.xyz *= shadow;
o.w = mtl.opacity;
return o;
}
vec4 frag () {
LightInfo phongLighting;
vec3 viewDirection = normalize(eye - pos_w);
phongMaterial mtl = getPhongMaterial();
#if USE_ALPHA_TEST
if(mtl.opacity < alphaTestThreshold) discard;
#endif
vec3 normal = normalize(normal_w);
#if USE_NORMAL_TEXTURE
normal = getNormal(pos_w, normal);
#endif
phongLighting = getPhongLighting(normal, pos_w, viewDirection, mtl.glossiness);
phongLighting.diffuse += sceneAmbient;
#if USE_SHADOW_MAP
float shadow = 1.0;
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
shadow *= computeShadowESM(shadowMap_{id}, pos_lightspace_{id}, vDepth_{id}, depthScale_{id}, darkness_{id}, frustumEdgeFalloff_{id});
#pragma endFor
#endif
vec4 finalColor = composePhongShading(phongLighting, mtl, shadow);
#else
vec4 finalColor = composePhongShading(phongLighting, mtl, 1.0);
#endif
return linearToGammaSpaceRGBA(finalColor);
}
-67
View File
@@ -1,67 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec3 a_position;
attribute vec3 a_normal;
uniform mat4 model;
uniform mat4 viewProj;
uniform mat3 normalMatrix;
varying vec3 normal_w;
varying vec3 pos_w;
#if USE_NORMAL_TEXTURE || USE_DIFFUSE_TEXTURE || USE_EMISSIVE_TEXTURE
attribute vec2 a_uv0;
uniform vec2 mainTiling;
uniform vec2 mainOffset;
varying vec2 uv0;
#endif
#if USE_SKINNING
#include <skinning>
#endif
#if USE_SHADOW_MAP
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
uniform mat4 lightViewProjMatrix_{id};
uniform float minDepth_{id};
uniform float maxDepth_{id};
varying vec4 pos_lightspace_{id};
varying float vDepth_{id};
#pragma endFor
#endif
#endif
vec4 vert () {
vec4 pos = vec4(a_position, 1);
#if USE_SKINNING
mat4 skinMat = skinMatrix();
pos = skinMat * pos;
#endif
pos_w = (model * pos).xyz;
pos = viewProj * model * pos;
#if USE_NORMAL_TEXTURE || USE_DIFFUSE_TEXTURE || USE_EMISSIVE_TEXTURE
uv0 = a_uv0 * mainTiling + mainOffset;
#endif
vec4 normal = vec4(a_normal, 0);
#if USE_SKINNING
normal = skinMat * normal;
#endif
normal_w = normalMatrix * normal.xyz;
#if USE_SHADOW_MAP
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
pos_lightspace_{id} = lightViewProjMatrix_{id} * vec4(pos_w, 1.0);
vDepth_{id} = (pos_lightspace_{id}.z + minDepth_{id}) / (minDepth_{id} + maxDepth_{id});
#pragma endFor
#endif
#endif
return pos;
}
@@ -1,175 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
mat3 transpose(mat3 v) {
mat3 tmp;
tmp[0] = vec3(v[0].x, v[1].x, v[2].x);
tmp[1] = vec3(v[0].y, v[1].y, v[2].y);
tmp[2] = vec3(v[0].z, v[1].z, v[2].z);
return tmp;
}
void ClipQuadToHorizon(inout vec3 L[5], out int n) {
// detect clipping config
int config = 0;
if (L[0].z > 0.0) config += 1;
if (L[1].z > 0.0) config += 2;
if (L[2].z > 0.0) config += 4;
if (L[3].z > 0.0) config += 8;
config = 15;
// clip
n = 0;
if (config == 0)
{
// clip all
}
else if (config == 1) // V1 clip V2 V3 V4
{
n = 3;
L[1] = -L[1].z * L[0] + L[0].z * L[1];
L[2] = -L[3].z * L[0] + L[0].z * L[3];
}
else if (config == 2) // V2 clip V1 V3 V4
{
n = 3;
L[0] = -L[0].z * L[1] + L[1].z * L[0];
L[2] = -L[2].z * L[1] + L[1].z * L[2];
}
else if (config == 3) // V1 V2 clip V3 V4
{
n = 4;
L[2] = -L[2].z * L[1] + L[1].z * L[2];
L[3] = -L[3].z * L[0] + L[0].z * L[3];
}
else if (config == 4) // V3 clip V1 V2 V4
{
n = 3;
L[0] = -L[3].z * L[2] + L[2].z * L[3];
L[1] = -L[1].z * L[2] + L[2].z * L[1];
}
else if (config == 5) // V1 V3 clip V2 V4) impossible
{
n = 0;
}
else if (config == 6) // V2 V3 clip V1 V4
{
n = 4;
L[0] = -L[0].z * L[1] + L[1].z * L[0];
L[3] = -L[3].z * L[2] + L[2].z * L[3];
}
else if (config == 7) // V1 V2 V3 clip V4
{
n = 5;
L[4] = -L[3].z * L[0] + L[0].z * L[3];
L[3] = -L[3].z * L[2] + L[2].z * L[3];
}
else if (config == 8) // V4 clip V1 V2 V3
{
n = 3;
L[0] = -L[0].z * L[3] + L[3].z * L[0];
L[1] = -L[2].z * L[3] + L[3].z * L[2];
L[2] = L[3];
}
else if (config == 9) // V1 V4 clip V2 V3
{
n = 4;
L[1] = -L[1].z * L[0] + L[0].z * L[1];
L[2] = -L[2].z * L[3] + L[3].z * L[2];
}
else if (config == 10) // V2 V4 clip V1 V3) impossible
{
n = 0;
}
else if (config == 11) // V1 V2 V4 clip V3
{
n = 5;
L[4] = L[3];
L[3] = -L[2].z * L[3] + L[3].z * L[2];
L[2] = -L[2].z * L[1] + L[1].z * L[2];
}
else if (config == 12) // V3 V4 clip V1 V2
{
n = 4;
L[1] = -L[1].z * L[2] + L[2].z * L[1];
L[0] = -L[0].z * L[3] + L[3].z * L[0];
}
else if (config == 13) // V1 V3 V4 clip V2
{
n = 5;
L[4] = L[3];
L[3] = L[2];
L[2] = -L[1].z * L[2] + L[2].z * L[1];
L[1] = -L[1].z * L[0] + L[0].z * L[1];
}
else if (config == 14) // V2 V3 V4 clip V1
{
n = 5;
L[4] = -L[0].z * L[3] + L[3].z * L[0];
L[0] = -L[0].z * L[1] + L[1].z * L[0];
}
else if (config == 15) // V1 V2 V3 V4
{
n = 4;
}
if (n == 3)
L[3] = L[0];
if (n == 4)
L[4] = L[0];
}
// https://eheitzresearch.wordpress.com/415-2/
float IntegrateEdge(vec3 v1, vec3 v2) {
float cosTheta = dot(v1, v2);
float theta = acos(cosTheta);
return cross(v1, v2).z * ((theta > 0.001) ? theta/sin(theta) : 4.0);
}
vec3 LTC_Evaluate(vec3 N, vec3 V, vec3 P, mat3 Minv, vec3 points[4]) {
// construct orthonormal basis around N
vec3 T1, T2;
T1 = normalize(V - N*dot(V, N));
T2 = cross(N, T1);
// rotate area light in (T1, T2, N) basis
Minv = Minv * transpose(mat3(T1, T2, N));
// polygon (allocate 5 vertices for clipping)
vec3 L[5];
L[0] = Minv * (points[0] - P);
L[1] = Minv * (points[1] - P);
L[2] = Minv * (points[2] - P);
L[3] = Minv * (points[3] - P);
int n;
ClipQuadToHorizon(L, n);
if (n == 0)
return vec3(0, 0, 0);
// project onto sphere
L[0] = normalize(L[0]);
L[1] = normalize(L[1]);
L[2] = normalize(L[2]);
L[3] = normalize(L[3]);
L[4] = normalize(L[4]);
// integrate
float sum = 0.0;
sum += IntegrateEdge(L[0], L[1]);
sum += IntegrateEdge(L[1], L[2]);
sum += IntegrateEdge(L[2], L[3]);
if (n >= 4)
sum += IntegrateEdge(L[3], L[4]);
if (n == 5)
sum += IntegrateEdge(L[4], L[0]);
sum = max(0.0, sum);
vec3 Lo_i = vec3(sum, sum, sum);
return Lo_i;
}
@@ -1,14 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
uniform float depthScale;
varying float vDepth;
#include <packing>
vec4 frag() {
// doing exp() here will cause float precision issue.
//float depth = clamp(exp(-min(87.0, depthScale * vDepth)), 0.0, 1.0);
return packDepthToRGBA(vDepth);
// TODO: if support float32 * 4 color buffer?
//gl_FragColor = vec4(depth, 1.0, 1.0, 1.0);
}
@@ -1,27 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec3 a_position;
uniform mat4 model;
uniform mat4 lightViewProjMatrix;
uniform float minDepth;
uniform float maxDepth;
uniform float bias;
varying float vDepth;
#if USE_SKINNING
#include <skinning>
#endif
vec4 vert() {
vec4 pos = vec4(a_position, 1);
#if USE_SKINNING
mat4 skinMat = skinMatrix();
pos = skinMat * pos;
#endif
// compute vDepth according to active camera's minDepth and maxDepth.
vDepth = ((gl_Position.z + minDepth) / (minDepth + maxDepth)) + bias;
return lightViewProjMatrix * model * pos;
}
@@ -1,75 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
#if NUM_SHADOW_LIGHTS > 0
#pragma for id in range(0, NUM_SHADOW_LIGHTS)
uniform sampler2D shadowMap_{id};
uniform float darkness_{id};
uniform float depthScale_{id};
uniform float frustumEdgeFalloff_{id};
uniform float bias_{id};
uniform vec2 texelSize_{id};
varying vec4 pos_lightspace_{id};
varying float vDepth_{id};
#pragma endFor
#endif
float computeShadow(sampler2D shadowMap, vec4 pos_lightspace, float bias) {
vec3 projCoords = pos_lightspace.xyz / pos_lightspace.w;
projCoords = projCoords * 0.5 + 0.5;
float closestDepth = unpackRGBAToDepth(texture2D(shadowMap, projCoords.xy));
float currentDepth = projCoords.z;
float shadow = (currentDepth - bias > closestDepth) ? 0.0 : 1.0;
return shadow;
}
float computeFallOff(float esm, vec2 coords, float frustumEdgeFalloff) {
float mask = smoothstep(1.0 - frustumEdgeFalloff, 1.0, clamp(dot(coords, coords), 0.0, 1.0));
return mix(esm, 1.0, mask);
}
// unused for float precision issue.
// float computeShadowESM_Unused() {
// vec2 projCoords = pos_lightspace.xy / pos_lightspace.w;
// vec2 shadowUV = projCoords * 0.5 + vec2(0.5);
// if (shadowUV.x < 0.0 || shadowUV.x > 1.0 || shadowUV.y < 0.0 || shadowUV.y > 1.0) {
// return 1.0;
// }
// float currentDepth = clamp(vDepth, 0.0, 1.0);
// float closestDepth = unpackRGBAToDepth(texture2D(shadowMap, shadowUV));
// float esm = 1.0 - clamp(exp(min(87.0, depthScale * currentDepth)) * closestDepth, 0.0, darkness);
// return computeFallOff(esm, projCoords, frustumEdgeFalloff);
// }
float computeShadowESM(sampler2D shadowMap, vec4 pos_lightspace, float vDepth, float depthScale, float darkness, float frustumEdgeFalloff) {
vec2 projCoords = pos_lightspace.xy / pos_lightspace.w;
vec2 shadowUV = projCoords * 0.5 + vec2(0.5);
if (shadowUV.x < 0.0 || shadowUV.x > 1.0 || shadowUV.y < 0.0 || shadowUV.y > 1.0) {
return 1.0;
}
float currentDepth = clamp(vDepth, 0.0, 1.0);
float closestDepth = unpackRGBAToDepth(texture2D(shadowMap, shadowUV));
//float esm = clamp(exp(min(87.0, -depthScale * (currentDepth - closestDepth))), 1.0 - darkness, 1.0);
float esm = clamp(exp(-depthScale * (currentDepth - closestDepth)), 1.0 - darkness, 1.0);
return computeFallOff(esm, projCoords, frustumEdgeFalloff);
}
float computeShadowPCF(sampler2D shadowMap, vec4 pos_lightspace, float vDepth, float darkness, vec2 texelSize, float frustumEdgeFalloff) {
vec2 projCoords = pos_lightspace.xy / pos_lightspace.w;
vec2 shadowUV = projCoords * 0.5 + vec2(0.5);
if (shadowUV.x < 0.0 || shadowUV.x > 1.0 || shadowUV.y < 0.0 || shadowUV.y > 1.0) {
return 1.0;
}
float currentDepth = clamp(vDepth, 0.0, 1.0);
float visibility = 1.0;
vec2 poissonDisk[4];
poissonDisk[0] = vec2(-0.94201624, -0.39906216);
poissonDisk[1] = vec2(0.94558609, -0.76890725);
poissonDisk[2] = vec2(-0.094184101, -0.92938870);
poissonDisk[3] = vec2(0.34495938, 0.29387760);
if (unpackRGBAToDepth(texture2D(shadowMap, shadowUV + poissonDisk[0] * texelSize)) < currentDepth) visibility -= 0.25;
if (unpackRGBAToDepth(texture2D(shadowMap, shadowUV + poissonDisk[1] * texelSize)) < currentDepth) visibility -= 0.25;
if (unpackRGBAToDepth(texture2D(shadowMap, shadowUV + poissonDisk[2] * texelSize)) < currentDepth) visibility -= 0.25;
if (unpackRGBAToDepth(texture2D(shadowMap, shadowUV + poissonDisk[3] * texelSize)) < currentDepth) visibility -= 0.25;
return computeFallOff(min(1.0, visibility + 1.0 - darkness), projCoords, frustumEdgeFalloff);
}
-43
View File
@@ -1,43 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec4 a_weights;
attribute vec4 a_joints;
#if USE_JOINTS_TEXTURE
uniform sampler2D u_jointsTexture;
uniform float u_jointsTextureSize;
mat4 getBoneMatrix(const in float i) {
float size = u_jointsTextureSize;
float j = i * 4.0;
float x = mod(j, size);
float y = floor(j / size);
float dx = 1.0 / size;
float dy = 1.0 / size;
y = dy * (y + 0.5);
vec4 v1 = texture2D(u_jointsTexture, vec2(dx * (x + 0.5), y));
vec4 v2 = texture2D(u_jointsTexture, vec2(dx * (x + 1.5), y));
vec4 v3 = texture2D(u_jointsTexture, vec2(dx * (x + 2.5), y));
vec4 v4 = texture2D(u_jointsTexture, vec2(dx * (x + 3.5), y));
return mat4(v1, v2, v3, v4);
}
#else
uniform mat4 u_jointMatrices[128];
mat4 getBoneMatrix(const in float i) {
return u_jointMatrices[int(i)];
}
#endif
mat4 skinMatrix() {
return
getBoneMatrix(a_joints.x) * a_weights.x +
getBoneMatrix(a_joints.y) * a_weights.y +
getBoneMatrix(a_joints.z) * a_weights.z +
getBoneMatrix(a_joints.w) * a_weights.w
;
}
-14
View File
@@ -1,14 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
uniform sampler2D mainTexture;
varying vec2 uv0;
varying vec4 color;
vec4 frag () {
vec4 o = vec4(1, 1, 1, 1);
o *= texture2D(mainTexture, uv0);
o *= color;
return o;
}
-22
View File
@@ -1,22 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec3 a_position;
uniform mat4 model;
uniform mat4 viewProj;
attribute vec2 a_uv0;
attribute vec4 a_color;
varying vec2 uv0;
varying vec4 color;
vec4 vert () {
vec4 pos = vec4(a_position, 1);
pos = viewProj * model * pos;
uv0 = a_uv0;
color = a_color;
return pos;
}
-24
View File
@@ -1,24 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
#if USE_TEXTURE
uniform sampler2D mainTexture;
varying vec2 uv0;
#endif
#if USE_COLOR
uniform vec4 color;
#endif
vec4 frag () {
vec4 o = vec4(1, 1, 1, 1);
#if USE_TEXTURE
o *= texture2D(mainTexture, uv0);
#endif
#if USE_COLOR
o *= color;
#endif
return o;
}
-33
View File
@@ -1,33 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
attribute vec3 a_position;
uniform mat4 model;
uniform mat4 viewProj;
#if USE_TEXTURE
attribute vec2 a_uv0;
uniform vec2 mainTiling;
uniform vec2 mainOffset;
varying vec2 uv0;
#endif
#if USE_SKINNING
#include <skinning>
#endif
vec4 vert () {
vec4 pos = vec4(a_position, 1);
#if USE_SKINNING
pos = skinMatrix() * pos;
#endif
pos = viewProj * model * pos;
#if USE_TEXTURE
uv0 = a_uv0 * mainTiling + mainOffset;
#endif
return pos;
}
-9
View File
@@ -1,9 +0,0 @@
// Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
vec3 unpackNormal(vec4 nmap) {
return nmap.xyz * 2.0 - 1.0;
}
vec3 unpackRGBE(vec4 rgbe) {
return rgbe.rgb * pow(2.0, rgbe.a * 255.0 - 128.0);
}
-400
View File
@@ -1,400 +0,0 @@
'use strict';
const tokenizer = require('glsl-tokenizer/string');
const mappings = require('../../../bin/mappings');
const { sha3_224 } = require('js-sha3');
let includeRE = /#include +<([\w-.]+)>/gm;
let defineRE = /#define\s+(\w+)\(([\w,\s]+)\)\s+(.*##.*)\n/g;
let whitespaces = /\s+/g;
let ident = /^[_a-zA-Z]\w*$/;
let extensionRE = /(?:GL_)?(\w+)/;
let comparators = /^[<=>]+$/;
let ifprocessor = /#(el)?if/;
let rangePragma = /range\(([\d.,\s]+)\)\s(\w+)/;
let defaultPragma = /default\(([\d.,]+)\)/;
let namePragma = /name\(([^)]+)\)/;
let precision = /(low|medium|high)p/;
// (HACKY) extract all builtin uniforms to the ignore list
let uniformIgnoreList = (function() {
const fs = require('fs');
let result = new Set(), extract = function(path) {
let renderer = fs.readFileSync(path, { encoding: 'utf8' });
let re = /set(Uniform|Texture)\([`'"](\w+)[`'"]/g, cap = re.exec(renderer);
while (cap) { result[cap[2]] = true; cap = re.exec(renderer); }
};
extract('resources/3d/engine/cocos/renderer/renderers/forward-renderer.js');
extract('resources/3d/engine/cocos/renderer/core/base-renderer.js');
return result;
})();
function convertType(t) { let tp = mappings.typeParams[t.toUpperCase()]; return tp === undefined ? t : tp; }
function unwindIncludes(str, chunks) {
function replace(match, include) {
let replace = chunks[include];
if (replace === undefined) {
console.error(`can not resolve #include <${include}>`);
}
return unwindIncludes(replace, chunks);
}
return str.replace(includeRE, replace);
}
function glslStripComment(code) {
let tokens = tokenizer(code);
let result = '';
for (let i = 0; i < tokens.length; ++i) {
let t = tokens[i];
if (t.type != 'block-comment' && t.type != 'line-comment' && t.type != 'eof') {
result += t.data;
}
}
return result;
}
function extractDefines(tokens, defines, cache) {
let curDefs = [], save = (line) => {
cache[line] = curDefs.reduce((acc, val) => acc.concat(val), []);
cache.lines.push(line);
};
for (let i = 0; i < tokens.length; ++i) {
let t = tokens[i], str = t.data, id, df;
if (t.type !== 'preprocessor') continue;
str = str.split(whitespaces);
if (str[0] === '#endif') {
curDefs.pop(); save(t.line); continue;
} else if (str[0] === '#else') {
curDefs[curDefs.length - 1].length = 0; save(t.line); continue;
} else if (str[0] === '#pragma') {
if (str[1] === 'for') { curDefs.push(0); save(t.line); }
else if (str[1] === 'endFor') { curDefs.pop(); save(t.line); }
else if (str[1][0] === '#') cache[t.line] = str.splice(1);
else {
let mc = rangePragma.exec(t.data);
if (!mc) continue;
let def = defines.find(d => d.name === mc[2]);
if (!def) defines.push(def = { name: mc[2] });
def.type = 'number';
def.range = JSON.parse(`[${mc[1]}]`);
}
continue;
} else if (!ifprocessor.test(str[0])) continue;
if (str[0] === '#elif') { curDefs.pop(); save(t.line); }
let defs = [];
str.splice(1).some(s => {
id = s.match(ident);
if (id) { // is identifier
defs.push(id[0]);
df = defines.find(d => d.name === id[0]);
if (df) return; // first encounter
defines.push(df = { name: id[0], type: 'boolean' });
} else if (comparators.test(s)) df.type = 'number';
else if (s === '||') return true;
});
curDefs.push(defs); save(t.line);
}
return defines;
}
function extractParams(tokens, cache, uniforms, attributes, extensions) {
let getDefs = line => {
let idx = cache.lines.findIndex(i => i > line);
return cache[cache.lines[idx - 1]] || [];
};
for (let i = 0; i < tokens.length; i++) {
let t = tokens[i], tp = t.type, str = t.data, dest;
if (tp === 'keyword' && str === 'uniform') dest = uniforms;
else if (tp === 'keyword' && str === 'attribute') dest = attributes;
else if (tp === 'preprocessor' && str.startsWith('#extension')) dest = extensions;
else continue;
let defines = getDefs(t.line), param = {};
if (defines.findIndex(i => !i) >= 0) continue; // inside pragmas
if (dest === uniforms && uniformIgnoreList[tokens[i+4].data]) continue;
if (dest === extensions) {
if (defines.length !== 1) console.warn('extensions must be under controll of exactly 1 define');
param.name = extensionRE.exec(str.split(whitespaces)[1])[1];
param.define = defines[0];
dest.push(param);
continue;
} else { // uniforms and attributes
let offset = precision.exec(tokens[i+2].data) ? 4 : 2;
param.name = tokens[i+offset+2].data;
param.type = convertType(tokens[i+offset].data);
let tags = cache[t.line - 1];
if (tags && tags[0][0] === '#') { // tags
let mc = defaultPragma.exec(tags.join(''));
if (mc && mc[1].length > 0) {
mc = JSON.parse(`[${mc[1]}]`);
if (mc.length === 1) param.value = mc[0];
else param.value = mc;
}
mc = namePragma.exec(tags.join(' '));
if (mc) param.displayName = mc[1];
for (let j = 0; j < tags.length; j++) {
let tag = tags[j];
if (tag === '#color') param.type = convertType(param.type);
else if (tag === '#property') param.property = true;
}
}
}
param.defines = defines;
dest.push(param);
}
}
let expandStructMacro = (function() {
function matchParenthesisPair(string, startIdx) {
let parHead = startIdx;
let parTail = parHead;
let depth = 0;
for (let i = startIdx; i < string.length; i++)
if (string[i] === '(') { parHead = i; depth = 1; break; }
if (depth === 0) return parHead;
for (let i = parHead + 1; i < string.length; i++) {
if (string[i] === '(') depth++;
if (string[i] === ')') depth--;
if (depth === 0) { parTail = i; break; }
}
if (depth !== 0) return parHead;
return parTail;
}
function generateHypenRE(hyphen, macroParam) {
return '(' + [hyphen + macroParam + hyphen, hyphen + macroParam, macroParam + hyphen].join('|') + ')';
}
function generateParamRE(param) {
return '\\b' + param + '\\b';
}
return function (code) {
code = code.replace(/\\\n/g, '');
let defineCapture = defineRE.exec(code);
//defineCapture[1] - the macro name
//defineCapture[2] - the macro parameters
//defineCapture[3] - the macro body
while (defineCapture != null) {
let macroRE = new RegExp('\\n.*' + defineCapture[1] + '\\s*\\(', 'g');
let macroCapture = macroRE.exec(code);
while (macroCapture != null) {
let macroIndex = macroCapture[0].lastIndexOf(defineCapture[1]);
//the whole macro string,include name and arguments
let macroStr = code.slice(macroCapture.index + macroIndex, matchParenthesisPair(code, macroCapture.index + macroCapture[0].length - 1) + 1);
//the macro arguments list
let macroArguLine = macroStr.slice(macroCapture[0].length - macroIndex, -1);
//the string before macro's name in the matched line
let prefix = macroCapture[0].slice(0, macroIndex);
let containDefine = prefix.indexOf('#define') !== -1;
let containParenthesis = prefix.indexOf('(') !== -1;
let macroParams = defineCapture[2].split(',');
//erase the white space in the macro's parameters
for (let i = 0; i < macroParams.length; i++) {
macroParams[i] = macroParams[i].replace(/\s/g, '');
}
let macroArgus = macroArguLine.split(',');
for (let i = 0; i < macroArgus.length; i++) {
macroArgus[i] = macroArgus[i].replace(/\s/g, '');
}
//if the matched macro is defined in another macro, then just replace the parameters with the arguments
if (containDefine && containParenthesis) {
code = code.replace(new RegExp(defineCapture[1] + '\\(' + macroArguLine + '\\)', 'g'), (matched, offset) => {
//if the matched string is the marco we just found,the replace it
if (macroCapture.index + prefix.length == offset) {
let ret = defineCapture[3];
for (let i = 0; i < macroParams.length; i++) {
ret = ret.replace(new RegExp(generateParamRE(macroParams[i]), 'g'), macroArgus[i]);
}
return ret;
}
return matched;
});
//move the next match index to the beginning of the line,in case of the same macro on the same line.
macroRE.lastIndex -= macroCapture[0].length;
}
//if the matched macro is defined in the executable code block,we should consider the hypen sign('##')
if (!containDefine) {
let repStr = defineCapture[3];
for (let i = 0; i < macroParams.length; i++) {
let hypenRE = new RegExp(generateHypenRE('##', macroParams[i]), 'g');
if (hypenRE.test(repStr)) {
//replace the hypen sign
repStr = repStr.replace(hypenRE, macroArgus[i]);
} else {
repStr = repStr.replace(new RegExp(generateParamRE(macroParams[i]), 'g'), macroArgus[i]);
}
}
code = code.replace(macroStr, repStr);
//move the next match index to the beginning of the line,in case of the same macro on the same line.
macroRE.lastIndex -= macroCapture[0].length;
}
macroCapture = macroRE.exec(code);
}
defineCapture = defineRE.exec(code);
}
return code;
};
})();
let assembleShader = (function() {
let entryRE = /([\w-]+)(?::(\w+))?/;
let integrity = /void\s+main\s*\([\w\s,]*\)/;
let wrapperFactory = (vert, fn) => `\nvoid main() { ${vert ? 'gl_Position' : 'gl_FragColor'} = ${fn}(); }\n`;
return function(name, cache, vert) {
let entryCap = entryRE.exec(name), content = cache[entryCap[1]];
if (!content) { console.error(`shader ${entryCap[1]} not found!`); return ''; }
if (!entryCap[2]) {
if (!integrity.test(content)) console.warn(`shader main entry not found in ${name}!`);
return cache[name];
}
return content + wrapperFactory(vert, entryCap[2]);
};
})();
let buildShader = function(vertName, fragName, cache) {
let vert = assembleShader(vertName, cache, true);
let frag = assembleShader(fragName, cache);
let defines = [], defCache = { lines: [] }, tokens;
let uniforms = [], attributes = [], extensions = [];
vert = glslStripComment(vert);
vert = unwindIncludes(vert, cache);
vert = expandStructMacro(vert);
tokens = tokenizer(vert);
extractDefines(tokens, defines, defCache);
extractParams(tokens, defCache, uniforms, attributes, extensions);
defCache = { lines: [] };
frag = glslStripComment(frag);
frag = unwindIncludes(frag, cache);
frag = expandStructMacro(frag);
tokens = tokenizer(frag);
extractDefines(tokens, defines, defCache);
extractParams(tokens, defCache, uniforms, attributes, extensions);
return { vert, frag, defines, uniforms, attributes, extensions };
};
// ==================
// effects
// ==================
let queueRE = /(\w+)(?:([+-])(\d+))?/;
let parseQueue = function (queue) {
let m = queueRE.exec(queue);
if (m === null) return 0;
let q = mappings.RenderQueue[m[1].toUpperCase()];
if (m.length === 4) {
if (m[2] === '+') q += parseInt(m[3]);
if (m[2] === '-') q -= parseInt(m[3]);
}
return q;
};
function mapPassParam(p) {
let num;
switch (typeof p) {
case 'string':
num = parseInt(p);
return isNaN(num) ? mappings.passParams[p.toUpperCase()] : num;
case 'object':
return ((p[0] * 255) << 24 | (p[1] * 255) << 16 | (p[2] * 255) << 8 | (p[3] || 0) * 255) >>> 0;
}
return p;
}
function buildEffectJSON(json) {
// map param's type offline.
for (let j = 0; j < json.techniques.length; ++j) {
let jsonTech = json.techniques[j];
jsonTech.queue = parseQueue(jsonTech.queue ? jsonTech.queue : 'opaque');
if (jsonTech.priority == null) {
jsonTech.priority = 0;
}
for (let k = 0; k < jsonTech.passes.length; ++k) {
let pass = jsonTech.passes[k];
if (pass.stage == null) {
pass.stage = 'default';
}
for (let key in pass) {
if (key === "vert" || key === 'frag') continue;
pass[key] = mapPassParam(pass[key]);
}
}
}
for (let prop in json.properties) {
let info = json.properties[prop];
info.type = mappings.typeParams[info.type.toUpperCase()];
}
return json;
}
let parseEffect = (function() {
let effectRE = /%{([^%]+)%}/;
let blockRE = /%%\s*([\w-]+)\s*{([^]+)}/;
let parenRE = /[{}]/g;
let trimToSize = content => {
let level = 1, end = content.length;
content.replace(parenRE, (p, i) => {
if (p === '{') level++;
else if (level === 1) { end = i; level = 1e9; }
else level--;
});
return content.substring(0, end);
};
return function (content) {
let effectCap = effectRE.exec(content);
let effect = JSON.parse(`{${effectCap[1]}}`), templates = {};
content = content.substring(effectCap.index + effectCap[0].length);
let blockCap = blockRE.exec(content);
while (blockCap) {
let str = templates[blockCap[1]] = trimToSize(blockCap[2]);
content = content.substring(blockCap.index + str.length);
blockCap = blockRE.exec(content);
}
return { effect, templates };
};
})();
// (HACKY) fixed builtin headers
let chunksCache = (function() {
const path_ = require('path');
const fsJetpack = require('fs-jetpack');
const fs = require('fs');
let files = fsJetpack.find('resources/3d/engine/cocos/renderer/bin/chunks', { matching: ['**/*.inc'] }), cache = {};
for (let i = 0; i < files.length; ++i) {
let name = path_.basename(files[i], '.inc');
let content = fs.readFileSync(files[i], { encoding: 'utf8' });
cache[name] = glslStripComment(content);
}
return cache;
})();
let buildEffect = function (name, content) {
let { effect, templates } = parseEffect(content);
effect = buildEffectJSON(effect); effect.name = name;
Object.assign(templates, chunksCache);
let shaders = effect.shaders = [];
for (let j = 0; j < effect.techniques.length; ++j) {
let jsonTech = effect.techniques[j];
for (let k = 0; k < jsonTech.passes.length; ++k) {
let pass = jsonTech.passes[k];
let vert = pass.vert, frag = pass.frag;
let shader = buildShader(vert, frag, templates);
let name = sha3_224(shader.vert + shader.frag);
shader.name = pass.program = name;
delete pass.vert; delete pass.frag;
shaders.push(shader);
}
}
return effect;
};
// ==================
// exports
// ==================
module.exports = {
buildEffect
};
+17 -21
View File
@@ -571,10 +571,10 @@ export default class BaseRenderer {
view.getPosition(_camPos);
// update uniforms
this._device.setUniform('view', mat4.array(_a16_view, view._matView));
this._device.setUniform('proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('viewProj', mat4.array(_a16_viewProj, view._matViewProj));
this._device.setUniform('eye', vec3.array(_a3_camPos, _camPos));
this._device.setUniform('_view', mat4.array(_a16_view, view._matView));
this._device.setUniform('_proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('_viewProj', mat4.array(_a16_viewProj, view._matViewProj));
this._device.setUniform('_eye', vec3.array(_a3_camPos, _camPos));
// calculate sorting key
for (let i = 0; i < stageItems.length; ++i) {
@@ -607,10 +607,10 @@ export default class BaseRenderer {
view.getForward(_camFwd);
// update uniforms
this._device.setUniform('view', mat4.array(_a16_view, view._matView));
this._device.setUniform('proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('viewProj', mat4.array(_a16_viewProj, view._matViewProj));
this._device.setUniform('eye', vec3.array(_a3_camPos, _camPos));
this._device.setUniform('_view', mat4.array(_a16_view, view._matView));
this._device.setUniform('_proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('_viewProj', mat4.array(_a16_viewProj, view._matViewProj));
this._device.setUniform('_eye', vec3.array(_a3_camPos, _camPos));
// calculate zdist
for (let i = 0; i < stageItems.length; ++i) {
@@ -644,9 +644,9 @@ export default class BaseRenderer {
_renderOverlay(view, stageItems) {
// update uniforms
this._device.setUniform('view', mat4.array(_a16_view, view._matView));
this._device.setUniform('proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('viewProj', mat4.array(_a16_viewProj, view._matViewProj));
this._device.setUniform('_view', mat4.array(_a16_view, view._matView));
this._device.setUniform('_proj', mat4.array(_a16_proj, view._matProj));
this._device.setUniform('_viewProj', mat4.array(_a16_viewProj, view._matViewProj));
// sort items
stageItems.sort((a, b) => {
@@ -682,6 +682,12 @@ export default class BaseRenderer {
_int4_pool.reset();
_int64_pool.reset();
node.getWorldMatrix(_m4_tmp);
device.setUniform('_model', mat4.array(_float16_pool.add(), _m4_tmp));
mat3.normalFromMat4(_m3_tmp, _m4_tmp);
device.setUniform('_normalMatrix', mat3.array(_float9_pool.add(), _m3_tmp));
// set uniforms
for (let name in effect._properties) {
let propInfo = effect._properties[name];
@@ -691,16 +697,6 @@ export default class BaseRenderer {
prop = this._type2defaultValue[propInfo.type];
}
// set common uniforms
if (name === 'model') {
node.getWorldMatrix(_m4_tmp);
prop = _m4_tmp;
}
else if (name === 'normalMatrix') {
mat3.normalFromMat4(_m3_tmp, _m4_tmp);
prop = _m3_tmp;
}
if (prop === undefined || prop === null) {
console.warn(`Failed to set technique property ${name}, value not found.`);
continue;
+2 -2
View File
@@ -15,8 +15,8 @@ export default class Pass {
this._blend = false;
this._blendEq = gfx.BLEND_FUNC_ADD;
this._blendAlphaEq = gfx.BLEND_FUNC_ADD;
this._blendSrc = gfx.BLEND_ONE;
this._blendDst = gfx.BLEND_ZERO;
this._blendSrc = gfx.BLEND_SRC_ALPHA;
this._blendDst = gfx.BLEND_ONE_MINUS_SRC_ALPHA;
this._blendSrcAlpha = gfx.BLEND_ONE;
this._blendDstAlpha = gfx.BLEND_ZERO;
this._blendColor = 0xffffffff;
+1 -1
View File
@@ -633,7 +633,7 @@ export default class Device {
this._initExtension(builtin_exts[i]);
}
let exts = gl.getSupportedExtensions();
this._supportedExts = exts.reduce((acc, cur) => acc[cur] = true, {});
this._supportedExts = exts.reduce((acc, cur) => { acc[cur] = true; return acc; }, {});
this._initCaps();
this._initStates();
+28 -28
View File
@@ -144,55 +144,55 @@ export default class ForwardRenderer extends BaseRenderer {
}
_submitLightUniforms() {
this._device.setUniform('sceneAmbient', this._sceneAmbient);
this._device.setUniform('_sceneAmbient', this._sceneAmbient);
if (this._directionalLights.length > 0) {
for (let index = 0; index < this._directionalLights.length; ++index) {
let light = this._directionalLights[index];
this._device.setUniform(`dir_light${index}_direction`, light._directionUniform);
this._device.setUniform(`dir_light${index}_color`, light._colorUniform);
this._device.setUniform(`_dir_light${index}_direction`, light._directionUniform);
this._device.setUniform(`_dir_light${index}_color`, light._colorUniform);
}
}
if (this._pointLights.length > 0) {
for (let index = 0; index < this._pointLights.length; ++index) {
let light = this._pointLights[index];
this._device.setUniform(`point_light${index}_position`, light._positionUniform);
this._device.setUniform(`point_light${index}_color`, light._colorUniform);
this._device.setUniform(`point_light${index}_range`, light._range);
this._device.setUniform(`_point_light${index}_position`, light._positionUniform);
this._device.setUniform(`_point_light${index}_color`, light._colorUniform);
this._device.setUniform(`_point_light${index}_range`, light._range);
}
}
if (this._spotLights.length > 0) {
for (let index = 0; index < this._spotLights.length; ++index) {
let light = this._spotLights[index];
this._device.setUniform(`spot_light${index}_position`, light._positionUniform);
this._device.setUniform(`spot_light${index}_direction`, light._directionUniform);
this._device.setUniform(`spot_light${index}_color`, light._colorUniform);
this._device.setUniform(`spot_light${index}_range`, light._range);
this._device.setUniform(`spot_light${index}_spot`, light._spotUniform);
this._device.setUniform(`_spot_light${index}_position`, light._positionUniform);
this._device.setUniform(`_spot_light${index}_direction`, light._directionUniform);
this._device.setUniform(`_spot_light${index}_color`, light._colorUniform);
this._device.setUniform(`_spot_light${index}_range`, light._range);
this._device.setUniform(`_spot_light${index}_spot`, light._spotUniform);
}
}
}
_submitShadowStageUniforms(view) {
let light = view._shadowLight;
this._device.setUniform('minDepth', light.shadowMinDepth);
this._device.setUniform('maxDepth', light.shadowMaxDepth);
this._device.setUniform('bias', light.shadowBias);
this._device.setUniform('depthScale', light.shadowDepthScale);
this._device.setUniform('_minDepth', light.shadowMinDepth);
this._device.setUniform('_maxDepth', light.shadowMaxDepth);
this._device.setUniform('_bias', light.shadowBias);
this._device.setUniform('_depthScale', light.shadowDepthScale);
}
_submitOtherStagesUniforms() {
for (let index = 0; index < this._shadowLights.length; ++index) {
let light = this._shadowLights[index];
this._device.setUniform(`lightViewProjMatrix_${index}`, mat4.array(_a16_lightViewProj, light.viewProjMatrix));
this._device.setUniform(`minDepth_${index}`, light.shadowMinDepth);
this._device.setUniform(`maxDepth_${index}`, light.shadowMaxDepth);
this._device.setUniform(`bias_${index}`, light.shadowBias);
this._device.setUniform(`depthScale_${index}`, light.shadowDepthScale);
this._device.setUniform(`darkness_${index}`, light.shadowDarkness);
this._device.setUniform(`frustumEdgeFalloff_${index}`, light.frustumEdgeFalloff);
this._device.setUniform(`texelSize_${index}`, new Float32Array([1.0 / light.shadowResolution, 1.0 / light.shadowResolution]));
this._device.setUniform(`_lightViewProjMatrix_${index}`, mat4.array(_a16_lightViewProj, light.viewProjMatrix));
this._device.setUniform(`_minDepth_${index}`, light.shadowMinDepth);
this._device.setUniform(`_maxDepth_${index}`, light.shadowMaxDepth);
this._device.setUniform(`_bias_${index}`, light.shadowBias);
this._device.setUniform(`_depthScale_${index}`, light.shadowDepthScale);
this._device.setUniform(`_darkness_${index}`, light.shadowDarkness);
this._device.setUniform(`_frustumEdgeFalloff_${index}`, light.frustumEdgeFalloff);
this._device.setUniform(`_texelSize_${index}`, new Float32Array([1.0 / light.shadowResolution, 1.0 / light.shadowResolution]));
}
}
@@ -210,7 +210,7 @@ export default class ForwardRenderer extends BaseRenderer {
}
_shadowStage(item) {
this._device.setUniform('lightViewProjMatrix', mat4.array(_a16_viewProj, this._currentView._matViewProj));
this._device.setUniform('_lightViewProjMatrix', mat4.array(_a16_viewProj, this._currentView._matViewProj));
// update rendering
// this._submitLightUniforms();
@@ -240,7 +240,7 @@ export default class ForwardRenderer extends BaseRenderer {
for (let index = 0; index < this._shadowLights.length; ++index) {
let light = this._shadowLights[index];
this._device.setTexture(`shadowMap_${index}`, light.shadowMap, this._allocTextureUnit());
this._device.setTexture(`_shadowMap_${index}`, light.shadowMap, this._allocTextureUnit());
}
this._drawPass(item);
@@ -254,11 +254,11 @@ export default class ForwardRenderer extends BaseRenderer {
defines.USE_SKINNING = true;
if (model._jointsTexture != null) {
defines.USE_JOINTS_TEXTURE = true;
this._device.setTexture('u_jointsTexture', model._jointsTexture, this._allocTextureUnit());
this._device.setUniform('u_jointsTextureSize', model._jointsTexture._width);
this._device.setTexture('_u_jointsTexture', model._jointsTexture, this._allocTextureUnit());
this._device.setUniform('_u_jointsTextureSize', model._jointsTexture._width);
} else if (model._jointsMatrixArray != null) {
defines.USE_JOINTS_TEXTURE = false;
this._device.setUniform("u_jointMatrices", model._jointsMatrixArray);
this._device.setUniform("_u_jointMatrices", model._jointsMatrixArray);
}
this._draw(item);
+3 -3
View File
@@ -9,7 +9,7 @@ class Layers {
* @return {number} new layer's index
*/
static addLayer(name) {
if (Layers._nextAvailable > 31)
if (Layers._nextAvailable > 31)
return new Error('maximum layers reached.');
Layers[name] = (1 << Layers._nextAvailable++);
return Layers[name];
@@ -56,8 +56,8 @@ Layers.Gizmos = (1 << 2);
Layers.PanPlanes = (1 << 3);
// masks
Layers.All = Layers.makeExclusiveMask([Layers.Gizmos]);
Layers.RaycastMask = Layers.makeExclusiveMask([Layers.Gizmos, Layers.IgnoreRaycast]);
Layers.All = Layers.makeExclusiveMask([Layers.Gizmos, Layers.PanPlanes]);
Layers.RaycastMask = Layers.makeExclusiveMask([Layers.Gizmos, Layers.PanPlanes, Layers.IgnoreRaycast]);
export default Layers;
cc.Layers = Layers;
+1 -4
View File
@@ -11,8 +11,7 @@
"scripts": {
"server": "http-server . -p 8002",
"build": "npm run build:dev && npm run build:min",
"build:effect": "rollup -c ./rollup/mappings.config.js && node ./rollup/build-effect.js",
"build:dev": "npm run build:effect && rollup -c ./rollup/config.js",
"build:dev": "rollup -c ./rollup/config.js",
"build:min": "uglifyjs ./bin/cocos-3d.dev.js --mangle --source-map -o ./bin/cocos-3d.min.js",
"dev": "rollup -w -c ./rollup/config.js"
},
@@ -36,7 +35,6 @@
"event-stream": "3.3.2",
"fire-fs": "0.2.1",
"fs-jetpack": "^1.1.0",
"glsl-tokenizer": "^2.1.5",
"gulp": "^3.9.1",
"gulp-babel": "6.1.2",
"gulp-cached": "1.1.0",
@@ -55,7 +53,6 @@
"gulp-util": "3.0.6",
"http-server": "^0.11.1",
"jshint-stylish": "2.1.0",
"js-sha3": "^0.8.0",
"multipipe": "0.3.0",
"persistify": "^1.1.1",
"require-dir": "0.3.0",
@@ -0,0 +1,53 @@
<!DOCTYPE html>
<html lang="en">
<head>
<title>spec-scroll-view</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
<style>
body {
background-color: #333;
margin: 0px;
overflow: hidden;
}
.fit {
position: absolute;
top: 0;
bottom: 0;
left: 0;
right: 0;
}
</style>
</head>
<body class="fit">
<canvas id="canvas" tabindex="-1" class="fit"></canvas>
<script src="../bin/cocos-3d.dev.js"></script>
<!-- <script src="./loadScene.js"></script> -->
<script>
function write(name) {
let text = cc.primitives.toWavefrontOBJ(cc.primitives[name]());
let blob = new Blob([text], { type: 'text/plain' });
let anchor = document.createElement('a');
anchor.download = `${name}.obj`;
anchor.href = (window.webkitURL || window.URL).createObjectURL(blob);
anchor.dataset.downloadurl = ['text/plain', anchor.download, anchor.href].join(':');
anchor.click();
}
function onStart() {
// write('box');
// write('sphere');
// write('cylinder');
// write('capsule');
// write('cone');
write('torus');
// write('plane');
// write('quad');
}
cc.game.run({id:'canvas'}, onStart);
</script>
</body>
</html>
-55
View File
@@ -1,55 +0,0 @@
'use strict';
const shdcLib = require('../cocos/renderer/bin/shdc-lib');
const path_ = require('path');
const fs = require('fs');
const fsJetpack = require('fs-jetpack');
let stringifyShaders = (function() {
let newlines = /\n+/g;
let toOneLiner = o => '\n ' + JSON.stringify(o).replace(/([,:])/g, '$1 ');
return function (shaders) {
let code = '';
for (let i = 0; i < shaders.length; ++i) {
let { name, vert, frag, defines, uniforms, attributes, extensions } = shaders[i];
vert = vert.replace(newlines, '\\n');
frag = frag.replace(newlines, '\\n');
code += ' {\n';
code += ` "name": "${name}",\n`;
code += ` "vert": "${vert}",\n`;
code += ` "frag": "${frag}",\n`;
code += ' "defines": [';
code += defines.map(toOneLiner);
code += (defines.length ? '\n ' : '') + '],\n';
code += ' "uniforms": [';
code += uniforms.map(toOneLiner);
code += (uniforms.length ? '\n ' : '') + '],\n';
code += ' "attributes": [';
code += attributes.map(toOneLiner);
code += (attributes.length ? '\n ' : '') + '],\n';
code += ' "extensions": [';
code += extensions.map(toOneLiner);
code += (extensions.length ? '\n ' : '') + ']\n';
code += ' },\n';
}
return `[\n${code.slice(0, -2)}\n]`;
};
})();
let indent = (str, num) => str.replace(/\n/g, '\n'+' '.repeat(num));
let path = './cocos/3d/builtin/effects';
let dest = path_.join(path, 'index.json');
let files = fsJetpack.find(path, { matching: ['**/*.effect'] }), code = ``;
for (let i = 0; i < files.length; ++i) {
let name = path_.basename(files[i], '.effect');
let content = fs.readFileSync(files[i], { encoding: 'utf8' });
let effect = shdcLib.buildEffect(name, content);
code += ' {\n';
code += ` "name": "${effect.name}",\n`;
code += ` "techniques": ${JSON.stringify(effect.techniques)},\n`;
code += ` "properties": ${JSON.stringify(effect.properties)},\n`;
code += ` "shaders": ${indent(stringifyShaders(effect.shaders), 4)}\n`;
code += ' },\n';
}
fs.writeFileSync(dest, `[\n${code.slice(0, -2)}\n]\n`, { encoding: 'utf8' });
-35
View File
@@ -1,35 +0,0 @@
'use strict';
const fsJetpack = require('fs-jetpack');
const resolve = require('rollup-plugin-node-resolve');
console.log('rollup mappings...');
let dest = './bin';
let file = 'mappings';
let name = 'mappings';
let sourcemap = true;
let globals = {};
fsJetpack.dir(dest);
module.exports = {
input: './cocos/3d/misc/offline-mappings.js',
external: [],
plugins: [
resolve({
jsnext: false,
main: false,
root: process.cwd()
}),
],
output: [
{
file: `${dest}/${file}.js`,
format: 'cjs',
name,
globals,
sourcemap,
},
],
};