1 #include <stdio.h>
2 #include <math.h>
3 #include <assert.h>
4 #include <stdlib.h>
5
6 #include <pixelflinger2/pixelflinger2_interface.h>
7
ApproximatelyEqual(const Vector4 lhs,const Vector4 rhs,const float t)8 int ApproximatelyEqual(const Vector4 lhs, const Vector4 rhs, const float t)
9 {
10 if (fabs(lhs.x - rhs.x) > t)
11 return 0;
12 if (fabs(lhs.y - rhs.y) > t)
13 return 0;
14 if (fabs(lhs.z - rhs.z) > t)
15 return 0;
16 if (fabs(lhs.w - rhs.w) > t)
17 return 0;
18 return 1;
19 }
20
21 extern void * llvmCtx;
22
contextless_test()23 void contextless_test()
24 {
25 static const char vsGLSL [] =
26 "uniform vec4 uVec4; \n"
27 "uniform sampler2D sampler2d; \n"
28 "attribute vec4 aPosition; \n"
29 "attribute vec4 aTexCoord; \n"
30 "varying vec4 vTexCoord; \n"
31 "varying vec4 vTexColor; \n"
32 "void main() { \n"
33 " gl_Position = aPosition; \n"
34 " vTexCoord = aTexCoord; \n"
35 " vTexColor = texture2D(sampler2d, aTexCoord.zw); \n"
36 " gl_PointSize = 432.0; \n"
37 "}";
38 gl_shader_t * vs = GGLShaderCreate(GL_VERTEX_SHADER);
39 const char * infoLog = NULL;
40 if (!GGLShaderCompile(vs, vsGLSL, &infoLog)) {
41 printf("GGLShaderCompile vs failed:\n%s\n", infoLog);
42 assert(0);
43 }
44 static const char fsGLSL [] =
45 "uniform vec4 uVec4; \n"
46 "uniform sampler2D sampler2d; \n"
47 "varying vec4 vTexCoord; \n"
48 "varying vec4 vTexColor; \n"
49 "void main() { \n"
50 " gl_FragColor = texture2D(sampler2d, vTexCoord.zw); \n"
51 "}";
52 gl_shader_t * fs = GGLShaderCreate(GL_FRAGMENT_SHADER);
53 if (!GGLShaderCompile(fs, fsGLSL, &infoLog)) {
54 printf("GGLShaderCompile fs failed:\n%s\n", infoLog);
55 assert(0);
56 }
57 gl_shader_program_t * prog = GGLShaderProgramCreate();
58 unsigned glError = GL_NO_ERROR;
59 glError = GGLShaderAttach(prog, vs);
60 assert(GL_NO_ERROR == glError);
61 glError = GGLShaderAttach(prog, fs);
62 assert(GL_NO_ERROR == glError);
63 GGLShaderAttributeBind(prog, 4, "aPosition");
64 GGLShaderAttributeBind(prog, 5, "aTexCoord");
65 if (!GGLShaderProgramLink(prog, &infoLog)) {
66 printf("GGLShaderProgramLink failed:\n%s\n", infoLog);
67 assert(0);
68 }
69 // llvm::LLVMContext * llvmCtx = new llvm::LLVMContext();
70 GGLState_t gglState = {0};
71 unsigned texels0 [] = {0xff10ffff, 0x22222222, 0x66666666, 0xffffffff};
72 GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888,
73 2, 2, 1, // width, height, levelCount
74 texels0, GGL_CLAMP_TO_EDGE, GGL_CLAMP_TO_EDGE,
75 GGL_NEAREST, GGL_NEAREST
76 };
77 gglState.textureState.textures[0] = texture0;
78 gglState.textureState.textureData[0] = gglState.textureState.textures[0].levels;
79 gglState.textureState.textureDimensions[0 * 2 + 0] = gglState.textureState.textures[0].width;
80 gglState.textureState.textureDimensions[0 * 2 + 1] = gglState.textureState.textures[0].height;
81 GGLShaderUse(llvmCtx, &gglState, prog);
82
83 VertexInput_t input = {0, 0, 0, 0};
84 input.attributes[4] = VECTOR4_CTR(0,0,0,1);
85 input.attributes[5] = VECTOR4_CTR(0,0,0,0);
86 VertexOutput_t output = {0};
87 GGLProcessVertex(prog, &input, &output, NULL);
88 int vTexColor = -1;
89 GGLShaderVaryingLocation(prog, "vTexColor", &vTexColor);
90 if (vTexColor >= 0) {
91 if (memcmp(((Vector4 *)&output) + vTexColor, &VECTOR4_CTR(1,1,16/255.0f,1), sizeof(Vector4))) {
92 puts("((Vector4 *)&output)[vTexColor] != Vector4(1,1,0,1)");
93 assert(0);
94 }
95 } else {
96 puts("vTexColor < 0");
97 assert(0);
98 }
99
100 static const char fsGLSL1 [] =
101 "uniform vec4 uVec4; \n"
102 "uniform sampler2D sampler2d; \n"
103 "varying vec4 vTexCoord; \n"
104 "varying vec4 vTexColor; \n"
105 "void main() { \n"
106 " gl_FragColor = vTexColor; \n"
107 "}";
108 gl_shader_t * fs1 = GGLShaderCreate(GL_FRAGMENT_SHADER);
109 if (!GGLShaderCompile(fs1, fsGLSL1, &infoLog)) {
110 printf("GGLShaderCompile fs failed:\n%s\n", infoLog);
111 assert(0);
112 }
113 gl_shader_program_t * prog1 = GGLShaderProgramCreate();
114 glError = GGLShaderAttach(prog1, vs);
115 assert(GL_NO_ERROR == glError);
116 glError = GGLShaderAttach(prog1, fs1);
117 assert(GL_NO_ERROR == glError);
118 GGLShaderAttributeBind(prog1, 1, "aPosition");
119 GGLShaderAttributeBind(prog1, 2, "aTexCoord");
120 if (!GGLShaderProgramLink(prog1, &infoLog)) {
121 printf("GGLShaderProgramLink failed:\n%s\n", infoLog);
122 assert(0);
123 }
124
125 GGLShaderUse(llvmCtx, &gglState, prog1);
126 VertexInput_t input1 = {0};
127 input1.attributes[1] = VECTOR4_CTR(1,1,0,1);
128 input1.attributes[2] = VECTOR4_CTR(1,1,0,0);
129 VertexOutput_t output1 = {0};
130 GGLProcessVertex(prog1, &input1, &output1, NULL);
131 int vTexCoord = -1;
132 assert(2 == GGLShaderAttributeLocation(prog1, "aTexCoord"));
133 GGLShaderVaryingLocation(prog1, "vTexCoord", &vTexCoord);
134 if (vTexCoord >= 0) {
135 if (memcmp(((Vector4 *)&output1) + vTexCoord, input1.attributes + 2, sizeof(Vector4))) {
136 puts("((Vector4 *)&output1)[vTexCoord] != input1.attributes[1]");
137 assert(0);
138 }
139 } else {
140 puts("vTexCoord < 0");
141 assert(0);
142 }
143
144 puts("***\n finished contextless_test \n***");
145
146 GGLShaderProgramDelete(prog);
147 GGLShaderProgramDelete(prog1);
148
149 GLContextDctr();
150 }
151
cmain(int argc,char ** argv)152 int cmain(int argc, char **argv)
153 {
154 contextless_test();
155
156 const char * infoLog = NULL;
157
158 GGLInterface_t * ggl = CreateGGLInterface();
159
160 gl_shader_t * shader0 = ggl->ShaderCreate(ggl, GL_VERTEX_SHADER);
161 assert(shader0);
162 const char * glsl0 =
163 "uniform vec4 uVec4; \n"
164 "uniform sampler2D sampler2d; \n"
165 "attribute vec4 aPosition; \n"
166 "attribute vec4 aTexCoord; \n"
167 "varying vec4 vTexCoord; \n"
168 "varying vec4 vTexColor; \n"
169 "void main() { \n"
170 " gl_Position = aPosition; \n"
171 " vTexCoord = aTexCoord + uVec4; \n"
172 " vTexColor = texture2D(sampler2d, aTexCoord.zw); \n"
173 " gl_PointSize = 432; \n"
174 "}";
175 puts(glsl0);
176 GLboolean compileStatus = ggl->ShaderCompile(ggl, shader0, glsl0, &infoLog);
177 if (!compileStatus)
178 fprintf(stderr, "failed to compile vertex shader 0, infoLog: \n %s \n", infoLog);
179 assert(compileStatus);
180
181 gl_shader_t * shader1 = ggl->ShaderCreate(ggl, GL_FRAGMENT_SHADER);
182 assert(shader1);
183 const char * glsl1 =
184 "uniform vec4 uVec4; \n"
185 "uniform sampler2D sampler2d; \n"
186 "varying vec4 vTexCoord; \n"
187 "varying vec4 vTexColor; \n"
188 "void main() { \n"
189 " gl_FragColor = vTexCoord + vTexColor; \n"
190 "}";
191 puts(glsl1);
192 compileStatus = ggl->ShaderCompile(ggl, shader1, glsl1, &infoLog);
193 if (!compileStatus)
194 fprintf(stderr, "failed to compile fragment shader 0, infoLog: \n %s \n", infoLog);
195 assert(compileStatus);
196
197 gl_shader_program_t * program0 = ggl->ShaderProgramCreate(ggl);
198 assert(program0);
199
200 ggl->ShaderAttach(ggl, program0, shader0);
201 ggl->ShaderAttach(ggl, program0, shader1);
202 ggl->ShaderAttributeBind(program0, 2, "aTexCoord");
203 ggl->ShaderAttributeBind(program0, 3, "aPosition");
204
205 GLboolean linkStatus = ggl->ShaderProgramLink(program0, &infoLog);
206 if (!linkStatus)
207 fprintf(stderr, "failed to link program 0, infoLog: \n %s \n", infoLog);
208 assert(linkStatus);
209
210 ggl->ShaderUse(ggl, program0);
211
212 unsigned texels0 [] = {0xffffffff, 0x22222222, 0x66666666, 0xffffffff};
213 GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888,
214 2, 2, 1, // width, height, levelCount
215 texels0, GGL_CLAMP_TO_EDGE, GGL_MIRRORED_REPEAT, GGL_LINEAR, GGL_LINEAR
216 }; // levels, wrapS, wrapT, minFilter, magFilter
217
218 int sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d");
219 if (0 <= sampler2dLoc) {
220 int samplerUnit = -1;
221 //ggl->ShaderUniformGetiv(ggl, program0, sampler2dLoc, &samplerUnit);
222 samplerUnit = sampler2dLoc;
223 ggl->SetSampler(ggl, samplerUnit, &texture0);
224 }
225
226 Vector4 uVec4 = {1.125f, 1.5f, 1.75f, 1.75f};
227 int uVec4Loc = ggl->ShaderUniformLocation(program0, "uVec4");
228 ggl->ShaderUniform(program0, uVec4Loc, 1, &uVec4, GL_FLOAT_VEC4);
229
230 VertexInput_t v0 = {0};
231 v0.attributes[2] = VECTOR4_CTR(0,0,1,1); // aTexCoord
232 v0.attributes[3] = VECTOR4_CTR(0.25f, 0.25f, 0.5f,1); // aPosition
233
234 VertexOutput_t vout0 = {0};
235 ggl->ProcessVertex(ggl, &v0, &vout0);
236 if (memcmp(&vout0.position,&v0.attributes[3],sizeof(vout0.position))) {
237 fprintf(stderr, "gl_Position != aPosition \n");
238 assert(0);
239 }
240
241 int vTexCoordIndex = ggl->ShaderVaryingLocation(program0, "vTexCoord", NULL) - 2;
242 VECTOR4_OP_UNARY(vout0.varyings[vTexCoordIndex],-=,uVec4);
243 if (memcmp(&vout0.varyings[vTexCoordIndex],&v0.attributes[2],sizeof uVec4)) {
244 fprintf(stderr, "vTexCoord != aTexCoord + uVec4 \n");
245 assert(0);
246 }
247 Vector4 ones = {1,1,1,1};
248 int vTexColorIndex = ggl->ShaderVaryingLocation(program0, "vTexColor", NULL) - 2;
249 if (memcmp(&vout0.varyings[vTexColorIndex],&ones,sizeof ones)) { // should be the last texel color
250 fprintf(stderr, "vTexColor != Vector4(1,1,1,1) \n");
251 assert(0);
252 }
253 if (vout0.pointSize.x != 432) {
254 fprintf(stderr, "gl_PointSize != 432 \n");
255 assert(0);
256 }
257
258 v0.attributes[2] = VECTOR4_CTR(0,0, 1.5f, 1.5f);
259 texture0.wrapS = GGL_REPEAT;
260 texture0.wrapT = GGL_REPEAT;
261
262 sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d");
263 if (0 <= sampler2dLoc) {
264 int samplerUnit = -1;
265 //ggl->ShaderUniformGetiv(ggl, program0, sampler2dLoc, &samplerUnit);
266 samplerUnit = sampler2dLoc;
267 ggl->SetSampler(ggl, samplerUnit, &texture0);
268 }
269 ggl->ShaderUse(ggl, program0);
270 ggl->ProcessVertex(ggl, &v0, &vout0);
271 const float filtered = (float)(0xff + 0x22 + 0x66 + 0xff) / (4 * 0xff);
272 if (!ApproximatelyEqual(vout0.varyings[vTexColorIndex],
273 VECTOR4_CTR(filtered, filtered, filtered, filtered), 1.0f / 255)) {
274 fprintf(stderr, "failed linear filter and/or wrapS and wrapT test");
275 assert(0);
276 }
277
278 const unsigned width = 60, height = 100;
279
280 GGLSurface_t colorSurface = {width, height, GGL_PIXEL_FORMAT_RGBA_8888, malloc(width * height * 4)};
281 assert(colorSurface.data);
282 ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &colorSurface);
283
284 GGLSurface_t depthSurface = {width, height, GGL_PIXEL_FORMAT_Z_32, malloc(width * height * 4)};
285 assert(depthSurface.data);
286 ggl->SetBuffer(ggl, GL_DEPTH_BUFFER_BIT, &depthSurface);
287
288 GGLSurface_t stencilSurface = {width, height, GGL_PIXEL_FORMAT_S_8, malloc(width * height * 1)};
289 assert(stencilSurface.data);
290 ggl->SetBuffer(ggl, GL_STENCIL_BUFFER_BIT, &stencilSurface);
291
292 ggl->ClearColor(ggl, 0.1f, 0.1f, 0.1f, 1.0f);
293 ggl->ClearDepthf(ggl, 0.5f);
294
295 // TODO DXL test scanline and fs
296
297 free(colorSurface.data);
298 colorSurface.data = NULL;
299 free(depthSurface.data);
300 depthSurface.data = NULL;
301 free(stencilSurface.data);
302 stencilSurface.data = NULL;
303
304 ggl->ShaderProgramDelete(ggl, program0);
305
306 puts("*******************");
307 puts("*** end of test ***");
308 puts("*******************");
309
310 DestroyGGLInterface(ggl);
311 return 0;
312 }
313