shaderity/test/basic.test.js at master · actnwit/shaderity · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
const Shaderity = require('../dist/esm/index').default;
const simpleFragment = require('../dist/index_test').simpleFragment;
const dynamicTemplateFragment = require('../dist/index_test').dynamicTemplateFragment;
const insertDefinitionVertex = require('../dist/index_test').insertDefinitionVertex;
const reflectionVertexES1 = require('../dist/index_test').reflectionVertexES1;
const reflectionVertexES3 = require('../dist/index_test').reflectionVertexES3;


test('detect shader stage correctly', async() => {
  expect(simpleFragment.shaderStage).toBe('fragment');
  expect(simpleFragment.isFragmentShader).toBe(true);
});


test('test dynamic template', async() => {
  expect(Shaderity.fillTemplate(dynamicTemplateFragment, {
    var_a: `Line1
Line2
Line3`,
    var_b: 'foo'
  }).code).toBe(`precision mediump float;

in vec4 vColor;

Line1
Line2
Line3
foo

void main() {
  gl_FlagColor = zero_one(vColor);
}
`);
});

test('test insert definition', async() => {
  expect(Shaderity.insertDefinition(insertDefinitionVertex, 'GLSL_ES3').code).toBe(`#define GLSL_ES3
in vec3 position;

void main () {
  gl_Position = vec4(position, 1.0);
}
`);
});

test('test attribute variable reflection (ES1)', async() => {
  const reflection = Shaderity.createReflectionObject(reflectionVertexES1);
  reflection.reflect();
  expect(reflection.attributes[0]).toStrictEqual({
    name: 'a_position',
    type: 'vec3',
    semantic: 'POSITION'
  });
  expect(reflection.attributes[1]).toStrictEqual({
    name: 'a_uv',
    type: 'vec2',
    semantic: 'TEXCOORD_0'
  });
});

test('test varying variable reflection (ES1)', async() => {
  const reflection = Shaderity.createReflectionObject(reflectionVertexES1);
  reflection.reflect();
  expect(reflection.varyings[0]).toStrictEqual({
    name: 'v_position',
    type: 'vec3',
    inout: 'out'
  });
});

test('test uniform variable reflection (ES1)', async() => {
  const reflection = Shaderity.createReflectionObject(reflectionVertexES1);
  reflection.reflect();
  expect(reflection.uniforms[0]).toStrictEqual({
    name: 'u_worldMatrix',
    type: 'vec4',
    semantic: 'WorldMatrix'
  });
  expect(reflection.uniforms[1]).toStrictEqual({
    name: 'u_texture',
    type: 'sampler2D',
    semantic: 'DataTexture'
  });
});

test('test attribute variable reflection (ES3)', async() => {
  const reflection = Shaderity.createReflectionObject(reflectionVertexES3);
  reflection.reflect();
  expect(reflection.attributes[0]).toStrictEqual({
    name: 'a_position',
    type: 'vec3',
    semantic: 'POSITION'
  });
  expect(reflection.attributes[1]).toStrictEqual({
    name: 'a_uv',
    type: 'vec2',
    semantic: 'TEXCOORD_0'
  });
});

test('test varying variable reflection (ES3)', async() => {
  const reflection = Shaderity.createReflectionObject(reflectionVertexES3);
  reflection.reflect();
  expect(reflection.varyings[0]).toStrictEqual({
    name: 'v_position',
    type: 'vec3',
    inout: 'out'
  });
});