Revert "Working CCBReader int compression."

This reverts commit b228675.

Author: jtwigg

cocos2d-ui-tests/Resources-shared/Cards/cards.classic.plist

@@ -0,0 +1,35 @@
+#extension GL_OES_standard_derivatives : enable
+precision highp float;
+
+const float rmin = 0.414213562373095; // sqrt(2) - 1
+const float rmax = 1.0;
+
+const float pi = 3.14159265358979;
+
+float circles_mask(vec2 uv, float phase){
+	float r = mix(rmin, rmax, phase);
+	float l = length(mod(uv, 1.0)*2.0 - 1.0) - r;
+	float fw = fwidth(l)*0.5;
+	
+	return smoothstep(fw, -fw, l) + min(l/r*0.5, 0.0);
+}
+
+void main(void)
+{
+	vec2 uv = gl_FragCoord.xy/128.0;
+	float t0 = cc_Time[0];
+	float t = t0 +
+	length(3.0*sin(t0*vec2(-0.5,  0.9) + 0.5*uv)) +
+	length(3.0*sin(t0*vec2( 0.3, -0.7) + 0.5*uv));
+	
+	float phase1 = sin(t)*0.5 + 0.5;
+	float mask1 = circles_mask(uv, phase1);
+	
+	float phase2 = sin(t + pi)*0.5 + 0.5;
+	float mask2 = circles_mask(uv + 0.5, phase2);
+	
+	vec4 color = vec4(1.0);
+	color = mix(color, vec4(1.0, 0.0, 0.0, 1.0), mask1);
+	color = mix(color, vec4(0.0, 0.5, 1.0, 0.5), mask2);
+	gl_FragColor = color;
+}

cocos2d-ui-tests/Resources-shared/Cards/cards.classic.png

@@ -0,0 +1,156 @@
+precision highp float;
+
+vec2 clip_coord()
+{
+	vec2 aspect = vec2(cc_ViewSize.x/cc_ViewSize.y, 1.0);
+	return 2.0*aspect*gl_FragCoord.xy/cc_ViewSize.xy - aspect;
+}
+
+vec3 eye_ray(vec3 eye, vec3 look_at, vec3 eye_up, float fov){
+	// Do as a matrix?
+	vec3 forward = normalize(look_at - eye);
+	vec3 right = cross(forward, normalize(eye_up));
+	vec3 up = cross(right, forward);
+	
+	vec2 clip = clip_coord();
+	return normalize(forward + (clip.x*fov)*right + clip.y*up);
+}
+
+float d_sphere(vec3 v, vec3 p, float r){
+	return length(v - p) - r;
+}
+
+float d_cylinder(vec3 v, vec3 p, vec3 n, float r, float l){
+	float dvn = dot(v - p, n);
+	return max(
+		length(v - n*dvn) - r,
+		abs(dvn) - l*0.5
+	);
+}
+
+float d_box(vec3 v, vec3 p, vec3 b){
+	vec3 d = abs(v - p) - b*0.5;
+	return max(max(d.x, d.y), d.z);
+}
+
+float d_union(float d1, float d2){ return min(d1, d2); }
+float d_subtract(float d1, float d2){ return max(d1, -d2); }
+float d_intersect(float d1, float d2){ return max(d1, d2); }
+
+float dist(vec3 v){
+	float s = 1.3;
+	float r = mix(1.6, 1.8, 0.5*sin(2.0*cc_Time[0]) + 0.5);
+	
+	float d = 1e10;
+	d = d_union(d, -d_box(v, vec3(0), vec3(10.0)));
+	d = d_union(d, d_box(v, vec3(0), vec3(2.0*s)));
+	d = d_subtract(d, d_sphere(v, vec3(0), r));
+	d = d_union(d, d_sphere(v, vec3(0), r*0.75));
+	d = d_union(d, d_cylinder(v, vec3(0), vec3(1,0,0), 0.2, 10.0));
+	d = d_union(d, d_cylinder(v, vec3(0), vec3(0,1,0), 0.2, 10.0));
+	d = d_union(d, d_cylinder(v, vec3(0), vec3(0,0,1), 0.2, 10.0));
+	return d;
+}
+
+const float g_eps = 1e-3;
+
+vec3 grad(vec3 p){
+	return normalize(vec3(
+		dist(p + vec3(g_eps,0,0)) - dist(p - vec3(g_eps,0,0)),
+		dist(p + vec3(0,g_eps,0)) - dist(p - vec3(0,g_eps,0)),
+		dist(p + vec3(0,0,g_eps)) - dist(p - vec3(0,0,g_eps))
+	));
+}
+
+const int iterations = 32;
+const float threshold = 1e-3;
+const float min_step = 1e-4;
+const float step_fraction = 0.75;
+
+struct Hit {
+	vec3 p, n;
+	float d;
+};
+
+Hit raymarch(vec3 eye, vec3 ray){
+	float dsum = 0.0;
+	for(int i=0; i<iterations; i++){
+		vec3 p = eye + dsum*ray;
+		float dmin = dist(p);
+		if(dmin < threshold){
+			return Hit(p, grad(p), dsum);
+		} else {
+			dsum += max(min_step, dmin*step_fraction);
+		}
+	}
+	
+	vec3 p = eye + dsum*ray;
+	return Hit(p, vec3(0), dsum);
+}
+
+const float ao_samples = 4.0;
+const float ao_spacing = 0.3;
+const float ao_strength = 4.0;
+
+float ao(Hit hit){
+	float sum = 0.0;
+	for(float i=1.0; i<=ao_samples; i++){
+		float d = i*ao_spacing;
+		sum += (d - dist(hit.p + hit.n*d))/pow(2.0, i);
+	}
+	
+	return 1.0 - ao_strength*sum;
+}
+
+const int shadow_iterations = 64;
+
+float shadowmarch(vec3 point, vec3 light){
+	vec3 delta = light - point;
+	float dmax = length(delta);
+	vec3 ray = delta/dmax;
+	
+	float shadow = 1.0;
+	float dsum = 0.1;
+	for(int i=0; i<shadow_iterations; i++){
+		vec3 p = point + ray*dsum;
+		float d = dist(p);
+		if(d < 1e-6) return 0.0;
+		
+		dsum += max(min_step, d*step_fraction);
+		shadow = min(shadow, 128.0*d/dsum);
+		if(dsum > dmax) return shadow;
+	}
+	
+	return shadow;
+}
+
+void main(void)
+{
+	float t = cc_Time[0]/3.0;
+	vec3 eye = -4.0*normalize(vec3(-cos(t), cos(0.5*t), -sin(t)));
+	vec3 look_at = vec3(0);
+	vec3 up = vec3(0,sin(t),cos(t));
+	
+	vec3 ray = eye_ray(eye, look_at, up, 1.0);
+	Hit hit = raymarch(eye, ray);
+	vec3 albedo = abs(hit.n);
+	float occlusion = ao(hit);
+	vec3 color = albedo;
+	
+	vec3 light_pos = -eye.yzx;
+	vec3 light_dir = normalize(light_pos - hit.p);
+	float diff = clamp(dot(light_dir, hit.n), 0.0, 1.0);
+	
+	float spec = pow(clamp(dot(reflect(ray, hit.n), light_dir), 0.0, 1.0), 50.0);
+	float light = 0.5*diff + 1.0*spec;
+	float shadow = shadowmarch(hit.p, light_pos);
+	color *= occlusion*(light*shadow + 0.1);
+	
+	vec3 fog_color = abs(ray);
+	color = mix(color, fog_color, hit.d/12.0);
+	
+	// TODO add a curve to filter out the > 1.0 crustees
+	color += 0.5*albedo*pow(1.0 + dot(hit.n, ray), 4.0);
+	
+	gl_FragColor = vec4(color, 0);
+}

cocos2d-ui-tests/Resources-shared/CircleCells.fsh

@@ -0,0 +1,81 @@
+#extension GL_OES_standard_derivatives : enable
+precision highp float;
+
+const vec4 sky = vec4(0.5, 0.5, 1.0, 1.0);
+
+// Filter far away values to get rid of the flicker.
+vec4 checker_aa(vec3 coord){
+	coord *= 0.25;
+	coord += vec3(0.3);
+	vec3 tri = abs(mod(2.0*coord, 4.0) - vec3(2.0)) - vec3(1.0);
+	float value = tri.x*tri.z;
+	float fw = fwidth(value)*0.5;
+	return vec4(smoothstep(-fw, fw, value));
+}
+
+vec4 raytrace_plane(vec3 origin, vec3 dir){
+	float t = origin.y/dir.y;
+	vec3 point = origin - dir*t + vec3(0.0);
+	return mix(checker_aa(point), sky, step(0.0, t));
+}
+
+const vec3 center = vec3(0, 2, 0);
+float radius = 0.75;
+
+vec4 raytrace_sphere(vec3 origin, vec3 dir){
+	
+	vec3 a = origin - center;
+	vec3 b = a + dir;
+	float daa = dot(a, a);
+	float dab = dot(a, b);
+	
+	float qa = daa - 2.0*dab + dot(b, b);
+	float qb = -daa + dab;
+	float qc = daa - radius*radius;
+	
+	float det = qb*qb - qa*qc;
+	if(det >= 0.0){
+		float t = (-qb - sqrt(det))/(qa);
+		if(t >= 0.0){
+			vec3 n = normalize(mix(a, b, t));
+			vec3 point = origin + dir*t;
+			
+			vec3 diffuse = max(-n, 0.0);
+			vec3 ref = raytrace_plane(point, reflect(dir, n)).rgb;
+			
+			
+			return vec4(mix(diffuse, ref, 0.5), 1.0);
+		}
+	}
+	
+	return vec4(0.0);
+}
+
+vec4 raytrace()
+{
+	const float rate = 1.0;
+	float t = cc_Time[0];
+	vec2 sc = vec2(cos(t*rate), sin(t*rate));
+	
+	float dist = (0.5*sin(0.3*t) + 0.5) + radius + 0.05;
+	float height = 2.0*sin(0.6*t);
+	
+	// Do as a matrix?
+	vec3 forward = normalize(vec3(sc.y, -height, sc.x));
+	vec3 origin = center - dist*forward;
+	vec3 right = cross(forward, vec3(0,1,0));
+	vec3 up = cross(right, forward);
+	
+	float aspect = cc_ViewSizeInPixels.x/cc_ViewSizeInPixels.y;
+	vec2 clip = vec2(2)*gl_FragCoord.xy/cc_ViewSizeInPixels.xy - vec2(1);
+	vec3 dir = normalize(forward + (clip.x*aspect)*right + clip.y*up);
+	
+	vec4 sphere = raytrace_sphere(origin, dir);
+	vec4 plane = raytrace_plane(origin, dir);
+	return mix(plane, sphere, sphere.a);
+}
+
+void main(void)
+{
+	gl_FragColor = raytrace();
+}