Changed also JSON model files and exporters/converters to use CamelCase property names.

Only Blender 2.56 exporter and OBJ converter were tested. If somebody is using other ones, please reexport some files to be sure they work.

build/Three.js

@@ -373,11 +373,11 @@ z;F<G;F+=L)v(F);return G-z})(I);(function(z){var F,L=o.vertex_index_bytes*3+o.ma
 this.sortFacesByMaterial()};f.prototype=new THREE.Geometry;f.prototype.constructor=f;b(new f(c))},createModel:function(a,b,c){var d=function(f){var g=this;THREE.Geometry.call(this);THREE.Loader.prototype.init_materials(g,a.materials,f);(function(){var h,k,j,l,n;h=0;for(k=a.vertices.length;h<k;h+=3){j=a.vertices[h];l=a.vertices[h+1];n=a.vertices[h+2];THREE.Loader.prototype.v(g,j,l,n)}if(a.colors){h=0;for(k=a.colors.length;h<k;h+=3){j=a.colors[h];l=a.colors[h+1];n=a.colors[h+2];THREE.Loader.prototype.vc(g,
 j,l,n)}}})();(function(){function h(w,B){THREE.Loader.prototype.f3(g,w[B],w[B+1],w[B+2],w[B+3])}function k(w,B){THREE.Loader.prototype.f3n(g,a.normals,w[B],w[B+1],w[B+2],w[B+3],w[B+4],w[B+5],w[B+6])}function j(w,B){THREE.Loader.prototype.f4(g,w[B],w[B+1],w[B+2],w[B+3],w[B+4])}function l(w,B){THREE.Loader.prototype.f4n(g,a.normals,w[B],w[B+1],w[B+2],w[B+3],w[B+4],w[B+5],w[B+6],w[B+7],w[B+8])}function n(w,B){var H,u,I,o,M,e,ba,O,P;H=w[B];u=w[B+1];I=w[B+2];o=a.uvs[H*2];ba=a.uvs[H*2+1];M=a.uvs[u*2];O=
 a.uvs[u*2+1];e=a.uvs[I*2];P=a.uvs[I*2+1];THREE.Loader.prototype.uv3(g.uvs,o,ba,M,O,e,P);if(a.uvs2&&a.uvs2.length){o=a.uvs2[H*2];ba=a.uvs2[H*2+1];M=a.uvs2[u*2];O=a.uvs2[u*2+1];e=a.uvs2[I*2];P=a.uvs2[I*2+1];THREE.Loader.prototype.uv3(g.uvs2,o,1-ba,M,1-O,e,1-P)}}function v(w,B){var H,u,I,o,M,e,ba,O,P,V,T,Y;H=w[B];u=w[B+1];I=w[B+2];o=w[B+3];M=a.uvs[H*2];P=a.uvs[H*2+1];e=a.uvs[u*2];V=a.uvs[u*2+1];ba=a.uvs[I*2];T=a.uvs[I*2+1];O=a.uvs[o*2];Y=a.uvs[o*2+1];THREE.Loader.prototype.uv4(g.uvs,M,P,e,V,ba,T,O,Y);
-if(a.uvs2){M=a.uvs2[H*2];P=a.uvs2[H*2+1];e=a.uvs2[u*2];V=a.uvs2[u*2+1];ba=a.uvs2[I*2];T=a.uvs2[I*2+1];O=a.uvs2[o*2];Y=a.uvs2[o*2+1];THREE.Loader.prototype.uv4(g.uvs2,M,1-P,e,1-V,ba,1-T,O,1-Y)}}var p,q;p=0;for(q=a.triangles_uv.length;p<q;p+=7){h(a.triangles_uv,p);n(a.triangles_uv,p+4)}p=0;for(q=a.triangles_n_uv.length;p<q;p+=10){k(a.triangles_n_uv,p);n(a.triangles_n_uv,p+7)}p=0;for(q=a.quads_uv.length;p<q;p+=9){j(a.quads_uv,p);v(a.quads_uv,p+5)}p=0;for(q=a.quads_n_uv.length;p<q;p+=13){l(a.quads_n_uv,
-p);v(a.quads_n_uv,p+9)}p=0;for(q=a.triangles.length;p<q;p+=4)h(a.triangles,p);p=0;for(q=a.triangles_n.length;p<q;p+=7)k(a.triangles_n,p);p=0;for(q=a.quads.length;p<q;p+=5)j(a.quads,p);p=0;for(q=a.quads_n.length;p<q;p+=9)l(a.quads_n,p)})();(function(){var h,k,j,l;if(a.skinWeights){h=0;for(k=a.skinWeights.length;h<k;h+=2){j=a.skinWeights[h];l=a.skinWeights[h+1];THREE.Loader.prototype.sw(g,j,l,0,0)}}if(a.skinIndices){h=0;for(k=a.skinIndices.length;h<k;h+=2){j=a.skinIndices[h];l=a.skinIndices[h+1];THREE.Loader.prototype.si(g,
-j,l,0,0)}}THREE.Loader.prototype.bones(g,a.bones);THREE.Loader.prototype.animation(g,a.animation)})();this.computeCentroids();this.computeFaceNormals();this.sortFacesByMaterial()};d.prototype=new THREE.Geometry;d.prototype.constructor=d;b(new d(c))},bones:function(a,b){a.bones=b},animation:function(a,b){a.animation=b},si:function(a,b,c,d,f){a.skinIndices.push(new THREE.Vector4(b,c,d,f))},sw:function(a,b,c,d,f){a.skinWeights.push(new THREE.Vector4(b,c,d,f))},v:function(a,b,c,d){a.vertices.push(new THREE.Vertex(new THREE.Vector3(b,
-c,d)))},vc:function(a,b,c,d){var f=new THREE.Color(16777215);f.setRGB(b,c,d);a.colors.push(f)},f3:function(a,b,c,d,f){a.faces.push(new THREE.Face3(b,c,d,null,a.materials[f]))},f4:function(a,b,c,d,f,g){a.faces.push(new THREE.Face4(b,c,d,f,null,a.materials[g]))},f3n:function(a,b,c,d,f,g,h,k,j){g=a.materials[g];var l=b[k*3],n=b[k*3+1];k=b[k*3+2];var v=b[j*3],p=b[j*3+1];j=b[j*3+2];a.faces.push(new THREE.Face3(c,d,f,[new THREE.Vector3(b[h*3],b[h*3+1],b[h*3+2]),new THREE.Vector3(l,n,k),new THREE.Vector3(v,
-p,j)],g))},f4n:function(a,b,c,d,f,g,h,k,j,l,n){h=a.materials[h];var v=b[j*3],p=b[j*3+1];j=b[j*3+2];var q=b[l*3],w=b[l*3+1];l=b[l*3+2];var B=b[n*3],H=b[n*3+1];n=b[n*3+2];a.faces.push(new THREE.Face4(c,d,f,g,[new THREE.Vector3(b[k*3],b[k*3+1],b[k*3+2]),new THREE.Vector3(v,p,j),new THREE.Vector3(q,w,l),new THREE.Vector3(B,H,n)],h))},uv3:function(a,b,c,d,f,g,h){var k=[];k.push(new THREE.UV(b,c));k.push(new THREE.UV(d,f));k.push(new THREE.UV(g,h));a.push(k)},uv4:function(a,b,c,d,f,g,h,k,j){var l=[];l.push(new THREE.UV(b,
-c));l.push(new THREE.UV(d,f));l.push(new THREE.UV(g,h));l.push(new THREE.UV(k,j));a.push(l)},init_materials:function(a,b,c){a.materials=[];for(var d=0;d<b.length;++d)a.materials[d]=[THREE.Loader.prototype.createMaterial(b[d],c)]},createMaterial:function(a,b){function c(k){k=Math.log(k)/Math.LN2;return Math.floor(k)==k}function d(k,j){var l=new Image;l.onload=function(){if(!c(this.width)||!c(this.height)){var n=Math.pow(2,Math.round(Math.log(this.width)/Math.LN2)),v=Math.pow(2,Math.round(Math.log(this.height)/
-Math.LN2));k.image.width=n;k.image.height=v;k.image.getContext("2d").drawImage(this,0,0,n,v)}else k.image=this;k.needsUpdate=!0};l.src=j}var f,g,h;f="MeshLambertMaterial";g={color:15658734,opacity:1,map:null,lightMap:null,vertexColors:a.vertex_colors};a.shading&&a.shading=="Phong"&&(f="MeshPhongMaterial");if(a.map_diffuse&&b){h=document.createElement("canvas");g.map=new THREE.Texture(h);d(g.map,b+"/"+a.map_diffuse)}else if(a.col_diffuse){h=(a.col_diffuse[0]*255<<16)+(a.col_diffuse[1]*255<<8)+a.col_diffuse[2]*
-255;g.color=h;g.opacity=a.transparency}else if(a.a_dbg_color)g.color=a.a_dbg_color;if(a.map_lightmap&&b){h=document.createElement("canvas");g.lightMap=new THREE.Texture(h);d(g.lightMap,b+"/"+a.map_lightmap)}return new THREE[f](g)},extractUrlbase:function(a){a=a.split("/");a.pop();return a.join("/")}};
+if(a.uvs2){M=a.uvs2[H*2];P=a.uvs2[H*2+1];e=a.uvs2[u*2];V=a.uvs2[u*2+1];ba=a.uvs2[I*2];T=a.uvs2[I*2+1];O=a.uvs2[o*2];Y=a.uvs2[o*2+1];THREE.Loader.prototype.uv4(g.uvs2,M,1-P,e,1-V,ba,1-T,O,1-Y)}}var p,q;p=0;for(q=a.trianglesUvs.length;p<q;p+=7){h(a.trianglesUvs,p);n(a.trianglesUvs,p+4)}p=0;for(q=a.trianglesNormalsUvs.length;p<q;p+=10){k(a.trianglesNormalsUvs,p);n(a.trianglesNormalsUvs,p+7)}p=0;for(q=a.quadsUvs.length;p<q;p+=9){j(a.quadsUvs,p);v(a.quadsUvs,p+5)}p=0;for(q=a.quadsNormalsUvs.length;p<q;p+=
+13){l(a.quadsNormalsUvs,p);v(a.quadsNormalsUvs,p+9)}p=0;for(q=a.triangles.length;p<q;p+=4)h(a.triangles,p);p=0;for(q=a.trianglesNormals.length;p<q;p+=7)k(a.trianglesNormals,p);p=0;for(q=a.quads.length;p<q;p+=5)j(a.quads,p);p=0;for(q=a.quadsNormals.length;p<q;p+=9)l(a.quadsNormals,p)})();(function(){var h,k,j,l;if(a.skinWeights){h=0;for(k=a.skinWeights.length;h<k;h+=2){j=a.skinWeights[h];l=a.skinWeights[h+1];THREE.Loader.prototype.sw(g,j,l,0,0)}}if(a.skinIndices){h=0;for(k=a.skinIndices.length;h<k;h+=
+2){j=a.skinIndices[h];l=a.skinIndices[h+1];THREE.Loader.prototype.si(g,j,l,0,0)}}THREE.Loader.prototype.bones(g,a.bones);THREE.Loader.prototype.animation(g,a.animation)})();this.computeCentroids();this.computeFaceNormals();this.sortFacesByMaterial()};d.prototype=new THREE.Geometry;d.prototype.constructor=d;b(new d(c))},bones:function(a,b){a.bones=b},animation:function(a,b){a.animation=b},si:function(a,b,c,d,f){a.skinIndices.push(new THREE.Vector4(b,c,d,f))},sw:function(a,b,c,d,f){a.skinWeights.push(new THREE.Vector4(b,
+c,d,f))},v:function(a,b,c,d){a.vertices.push(new THREE.Vertex(new THREE.Vector3(b,c,d)))},vc:function(a,b,c,d){var f=new THREE.Color(16777215);f.setRGB(b,c,d);a.colors.push(f)},f3:function(a,b,c,d,f){a.faces.push(new THREE.Face3(b,c,d,null,a.materials[f]))},f4:function(a,b,c,d,f,g){a.faces.push(new THREE.Face4(b,c,d,f,null,a.materials[g]))},f3n:function(a,b,c,d,f,g,h,k,j){g=a.materials[g];var l=b[k*3],n=b[k*3+1];k=b[k*3+2];var v=b[j*3],p=b[j*3+1];j=b[j*3+2];a.faces.push(new THREE.Face3(c,d,f,[new THREE.Vector3(b[h*
+3],b[h*3+1],b[h*3+2]),new THREE.Vector3(l,n,k),new THREE.Vector3(v,p,j)],g))},f4n:function(a,b,c,d,f,g,h,k,j,l,n){h=a.materials[h];var v=b[j*3],p=b[j*3+1];j=b[j*3+2];var q=b[l*3],w=b[l*3+1];l=b[l*3+2];var B=b[n*3],H=b[n*3+1];n=b[n*3+2];a.faces.push(new THREE.Face4(c,d,f,g,[new THREE.Vector3(b[k*3],b[k*3+1],b[k*3+2]),new THREE.Vector3(v,p,j),new THREE.Vector3(q,w,l),new THREE.Vector3(B,H,n)],h))},uv3:function(a,b,c,d,f,g,h){var k=[];k.push(new THREE.UV(b,c));k.push(new THREE.UV(d,f));k.push(new THREE.UV(g,
+h));a.push(k)},uv4:function(a,b,c,d,f,g,h,k,j){var l=[];l.push(new THREE.UV(b,c));l.push(new THREE.UV(d,f));l.push(new THREE.UV(g,h));l.push(new THREE.UV(k,j));a.push(l)},init_materials:function(a,b,c){a.materials=[];for(var d=0;d<b.length;++d)a.materials[d]=[THREE.Loader.prototype.createMaterial(b[d],c)]},createMaterial:function(a,b){function c(k){k=Math.log(k)/Math.LN2;return Math.floor(k)==k}function d(k,j){var l=new Image;l.onload=function(){if(!c(this.width)||!c(this.height)){var n=Math.pow(2,
+Math.round(Math.log(this.width)/Math.LN2)),v=Math.pow(2,Math.round(Math.log(this.height)/Math.LN2));k.image.width=n;k.image.height=v;k.image.getContext("2d").drawImage(this,0,0,n,v)}else k.image=this;k.needsUpdate=!0};l.src=j}var f,g,h;f="MeshLambertMaterial";g={color:15658734,opacity:1,map:null,lightMap:null,vertexColors:a.vertexColors};a.shading&&a.shading=="Phong"&&(f="MeshPhongMaterial");if(a.mapDiffuse&&b){h=document.createElement("canvas");g.map=new THREE.Texture(h);d(g.map,b+"/"+a.mapDiffuse)}else if(a.colorDiffuse){h=
+(a.colorDiffuse[0]*255<<16)+(a.colorDiffuse[1]*255<<8)+a.colorDiffuse[2]*255;g.color=h;g.opacity=a.transparency}else if(a.DbgColor)g.color=a.DbgColor;if(a.mapLightmap&&b){h=document.createElement("canvas");g.lightMap=new THREE.Texture(h);d(g.lightMap,b+"/"+a.mapLightmap)}return new THREE[f](g)},extractUrlbase:function(a){a=a.split("/");a.pop();return a.join("/")}};

build/custom/ThreeExtras.js

@@ -96,11 +96,11 @@ o})(x);(function(o){var u,y=k.vertex_index_bytes*3+k.material_index_bytes+k.norm
 g.prototype=new THREE.Geometry;g.prototype.constructor=g;d(new g(b))},createModel:function(a,d,b){var f=function(g){var c=this;THREE.Geometry.call(this);THREE.Loader.prototype.init_materials(c,a.materials,g);(function(){var e,h,j,l,m;e=0;for(h=a.vertices.length;e<h;e+=3){j=a.vertices[e];l=a.vertices[e+1];m=a.vertices[e+2];THREE.Loader.prototype.v(c,j,l,m)}if(a.colors){e=0;for(h=a.colors.length;e<h;e+=3){j=a.colors[e];l=a.colors[e+1];m=a.colors[e+2];THREE.Loader.prototype.vc(c,j,l,m)}}})();(function(){function e(p,
 t){THREE.Loader.prototype.f3(c,p[t],p[t+1],p[t+2],p[t+3])}function h(p,t){THREE.Loader.prototype.f3n(c,a.normals,p[t],p[t+1],p[t+2],p[t+3],p[t+4],p[t+5],p[t+6])}function j(p,t){THREE.Loader.prototype.f4(c,p[t],p[t+1],p[t+2],p[t+3],p[t+4])}function l(p,t){THREE.Loader.prototype.f4n(c,a.normals,p[t],p[t+1],p[t+2],p[t+3],p[t+4],p[t+5],p[t+6],p[t+7],p[t+8])}function m(p,t){var z,w,x,k,D,E,J,A,C;z=p[t];w=p[t+1];x=p[t+2];k=a.uvs[z*2];J=a.uvs[z*2+1];D=a.uvs[w*2];A=a.uvs[w*2+1];E=a.uvs[x*2];C=a.uvs[x*2+1];
 THREE.Loader.prototype.uv3(c.uvs,k,J,D,A,E,C);if(a.uvs2&&a.uvs2.length){k=a.uvs2[z*2];J=a.uvs2[z*2+1];D=a.uvs2[w*2];A=a.uvs2[w*2+1];E=a.uvs2[x*2];C=a.uvs2[x*2+1];THREE.Loader.prototype.uv3(c.uvs2,k,1-J,D,1-A,E,1-C)}}function v(p,t){var z,w,x,k,D,E,J,A,C,H,I,K;z=p[t];w=p[t+1];x=p[t+2];k=p[t+3];D=a.uvs[z*2];C=a.uvs[z*2+1];E=a.uvs[w*2];H=a.uvs[w*2+1];J=a.uvs[x*2];I=a.uvs[x*2+1];A=a.uvs[k*2];K=a.uvs[k*2+1];THREE.Loader.prototype.uv4(c.uvs,D,C,E,H,J,I,A,K);if(a.uvs2){D=a.uvs2[z*2];C=a.uvs2[z*2+1];E=a.uvs2[w*
-2];H=a.uvs2[w*2+1];J=a.uvs2[x*2];I=a.uvs2[x*2+1];A=a.uvs2[k*2];K=a.uvs2[k*2+1];THREE.Loader.prototype.uv4(c.uvs2,D,1-C,E,1-H,J,1-I,A,1-K)}}var q,n;q=0;for(n=a.triangles_uv.length;q<n;q+=7){e(a.triangles_uv,q);m(a.triangles_uv,q+4)}q=0;for(n=a.triangles_n_uv.length;q<n;q+=10){h(a.triangles_n_uv,q);m(a.triangles_n_uv,q+7)}q=0;for(n=a.quads_uv.length;q<n;q+=9){j(a.quads_uv,q);v(a.quads_uv,q+5)}q=0;for(n=a.quads_n_uv.length;q<n;q+=13){l(a.quads_n_uv,q);v(a.quads_n_uv,q+9)}q=0;for(n=a.triangles.length;q<
-n;q+=4)e(a.triangles,q);q=0;for(n=a.triangles_n.length;q<n;q+=7)h(a.triangles_n,q);q=0;for(n=a.quads.length;q<n;q+=5)j(a.quads,q);q=0;for(n=a.quads_n.length;q<n;q+=9)l(a.quads_n,q)})();(function(){var e,h,j,l;if(a.skinWeights){e=0;for(h=a.skinWeights.length;e<h;e+=2){j=a.skinWeights[e];l=a.skinWeights[e+1];THREE.Loader.prototype.sw(c,j,l,0,0)}}if(a.skinIndices){e=0;for(h=a.skinIndices.length;e<h;e+=2){j=a.skinIndices[e];l=a.skinIndices[e+1];THREE.Loader.prototype.si(c,j,l,0,0)}}THREE.Loader.prototype.bones(c,
-a.bones);THREE.Loader.prototype.animation(c,a.animation)})();this.computeCentroids();this.computeFaceNormals();this.sortFacesByMaterial()};f.prototype=new THREE.Geometry;f.prototype.constructor=f;d(new f(b))},bones:function(a,d){a.bones=d},animation:function(a,d){a.animation=d},si:function(a,d,b,f,g){a.skinIndices.push(new THREE.Vector4(d,b,f,g))},sw:function(a,d,b,f,g){a.skinWeights.push(new THREE.Vector4(d,b,f,g))},v:function(a,d,b,f){a.vertices.push(new THREE.Vertex(new THREE.Vector3(d,b,f)))},
-vc:function(a,d,b,f){var g=new THREE.Color(16777215);g.setRGB(d,b,f);a.colors.push(g)},f3:function(a,d,b,f,g){a.faces.push(new THREE.Face3(d,b,f,null,a.materials[g]))},f4:function(a,d,b,f,g,c){a.faces.push(new THREE.Face4(d,b,f,g,null,a.materials[c]))},f3n:function(a,d,b,f,g,c,e,h,j){c=a.materials[c];var l=d[h*3],m=d[h*3+1];h=d[h*3+2];var v=d[j*3],q=d[j*3+1];j=d[j*3+2];a.faces.push(new THREE.Face3(b,f,g,[new THREE.Vector3(d[e*3],d[e*3+1],d[e*3+2]),new THREE.Vector3(l,m,h),new THREE.Vector3(v,q,j)],
-c))},f4n:function(a,d,b,f,g,c,e,h,j,l,m){e=a.materials[e];var v=d[j*3],q=d[j*3+1];j=d[j*3+2];var n=d[l*3],p=d[l*3+1];l=d[l*3+2];var t=d[m*3],z=d[m*3+1];m=d[m*3+2];a.faces.push(new THREE.Face4(b,f,g,c,[new THREE.Vector3(d[h*3],d[h*3+1],d[h*3+2]),new THREE.Vector3(v,q,j),new THREE.Vector3(n,p,l),new THREE.Vector3(t,z,m)],e))},uv3:function(a,d,b,f,g,c,e){var h=[];h.push(new THREE.UV(d,b));h.push(new THREE.UV(f,g));h.push(new THREE.UV(c,e));a.push(h)},uv4:function(a,d,b,f,g,c,e,h,j){var l=[];l.push(new THREE.UV(d,
+2];H=a.uvs2[w*2+1];J=a.uvs2[x*2];I=a.uvs2[x*2+1];A=a.uvs2[k*2];K=a.uvs2[k*2+1];THREE.Loader.prototype.uv4(c.uvs2,D,1-C,E,1-H,J,1-I,A,1-K)}}var q,n;q=0;for(n=a.trianglesUvs.length;q<n;q+=7){e(a.trianglesUvs,q);m(a.trianglesUvs,q+4)}q=0;for(n=a.trianglesNormalsUvs.length;q<n;q+=10){h(a.trianglesNormalsUvs,q);m(a.trianglesNormalsUvs,q+7)}q=0;for(n=a.quadsUvs.length;q<n;q+=9){j(a.quadsUvs,q);v(a.quadsUvs,q+5)}q=0;for(n=a.quadsNormalsUvs.length;q<n;q+=13){l(a.quadsNormalsUvs,q);v(a.quadsNormalsUvs,q+9)}q=
+0;for(n=a.triangles.length;q<n;q+=4)e(a.triangles,q);q=0;for(n=a.trianglesNormals.length;q<n;q+=7)h(a.trianglesNormals,q);q=0;for(n=a.quads.length;q<n;q+=5)j(a.quads,q);q=0;for(n=a.quadsNormals.length;q<n;q+=9)l(a.quadsNormals,q)})();(function(){var e,h,j,l;if(a.skinWeights){e=0;for(h=a.skinWeights.length;e<h;e+=2){j=a.skinWeights[e];l=a.skinWeights[e+1];THREE.Loader.prototype.sw(c,j,l,0,0)}}if(a.skinIndices){e=0;for(h=a.skinIndices.length;e<h;e+=2){j=a.skinIndices[e];l=a.skinIndices[e+1];THREE.Loader.prototype.si(c,
+j,l,0,0)}}THREE.Loader.prototype.bones(c,a.bones);THREE.Loader.prototype.animation(c,a.animation)})();this.computeCentroids();this.computeFaceNormals();this.sortFacesByMaterial()};f.prototype=new THREE.Geometry;f.prototype.constructor=f;d(new f(b))},bones:function(a,d){a.bones=d},animation:function(a,d){a.animation=d},si:function(a,d,b,f,g){a.skinIndices.push(new THREE.Vector4(d,b,f,g))},sw:function(a,d,b,f,g){a.skinWeights.push(new THREE.Vector4(d,b,f,g))},v:function(a,d,b,f){a.vertices.push(new THREE.Vertex(new THREE.Vector3(d,
+b,f)))},vc:function(a,d,b,f){var g=new THREE.Color(16777215);g.setRGB(d,b,f);a.colors.push(g)},f3:function(a,d,b,f,g){a.faces.push(new THREE.Face3(d,b,f,null,a.materials[g]))},f4:function(a,d,b,f,g,c){a.faces.push(new THREE.Face4(d,b,f,g,null,a.materials[c]))},f3n:function(a,d,b,f,g,c,e,h,j){c=a.materials[c];var l=d[h*3],m=d[h*3+1];h=d[h*3+2];var v=d[j*3],q=d[j*3+1];j=d[j*3+2];a.faces.push(new THREE.Face3(b,f,g,[new THREE.Vector3(d[e*3],d[e*3+1],d[e*3+2]),new THREE.Vector3(l,m,h),new THREE.Vector3(v,
+q,j)],c))},f4n:function(a,d,b,f,g,c,e,h,j,l,m){e=a.materials[e];var v=d[j*3],q=d[j*3+1];j=d[j*3+2];var n=d[l*3],p=d[l*3+1];l=d[l*3+2];var t=d[m*3],z=d[m*3+1];m=d[m*3+2];a.faces.push(new THREE.Face4(b,f,g,c,[new THREE.Vector3(d[h*3],d[h*3+1],d[h*3+2]),new THREE.Vector3(v,q,j),new THREE.Vector3(n,p,l),new THREE.Vector3(t,z,m)],e))},uv3:function(a,d,b,f,g,c,e){var h=[];h.push(new THREE.UV(d,b));h.push(new THREE.UV(f,g));h.push(new THREE.UV(c,e));a.push(h)},uv4:function(a,d,b,f,g,c,e,h,j){var l=[];l.push(new THREE.UV(d,
 b));l.push(new THREE.UV(f,g));l.push(new THREE.UV(c,e));l.push(new THREE.UV(h,j));a.push(l)},init_materials:function(a,d,b){a.materials=[];for(var f=0;f<d.length;++f)a.materials[f]=[THREE.Loader.prototype.createMaterial(d[f],b)]},createMaterial:function(a,d){function b(h){h=Math.log(h)/Math.LN2;return Math.floor(h)==h}function f(h,j){var l=new Image;l.onload=function(){if(!b(this.width)||!b(this.height)){var m=Math.pow(2,Math.round(Math.log(this.width)/Math.LN2)),v=Math.pow(2,Math.round(Math.log(this.height)/
-Math.LN2));h.image.width=m;h.image.height=v;h.image.getContext("2d").drawImage(this,0,0,m,v)}else h.image=this;h.needsUpdate=!0};l.src=j}var g,c,e;g="MeshLambertMaterial";c={color:15658734,opacity:1,map:null,lightMap:null,vertexColors:a.vertex_colors};a.shading&&a.shading=="Phong"&&(g="MeshPhongMaterial");if(a.map_diffuse&&d){e=document.createElement("canvas");c.map=new THREE.Texture(e);f(c.map,d+"/"+a.map_diffuse)}else if(a.col_diffuse){e=(a.col_diffuse[0]*255<<16)+(a.col_diffuse[1]*255<<8)+a.col_diffuse[2]*
-255;c.color=e;c.opacity=a.transparency}else if(a.a_dbg_color)c.color=a.a_dbg_color;if(a.map_lightmap&&d){e=document.createElement("canvas");c.lightMap=new THREE.Texture(e);f(c.lightMap,d+"/"+a.map_lightmap)}return new THREE[g](c)},extractUrlbase:function(a){a=a.split("/");a.pop();return a.join("/")}};
+Math.LN2));h.image.width=m;h.image.height=v;h.image.getContext("2d").drawImage(this,0,0,m,v)}else h.image=this;h.needsUpdate=!0};l.src=j}var g,c,e;g="MeshLambertMaterial";c={color:15658734,opacity:1,map:null,lightMap:null,vertexColors:a.vertexColors};a.shading&&a.shading=="Phong"&&(g="MeshPhongMaterial");if(a.mapDiffuse&&d){e=document.createElement("canvas");c.map=new THREE.Texture(e);f(c.map,d+"/"+a.mapDiffuse)}else if(a.colorDiffuse){e=(a.colorDiffuse[0]*255<<16)+(a.colorDiffuse[1]*255<<8)+a.colorDiffuse[2]*
+255;c.color=e;c.opacity=a.transparency}else if(a.DbgColor)c.color=a.DbgColor;if(a.mapLightmap&&d){e=document.createElement("canvas");c.lightMap=new THREE.Texture(e);f(c.lightMap,d+"/"+a.mapLightmap)}return new THREE[g](c)},extractUrlbase:function(a){a=a.split("/");a.pop();return a.join("/")}};

examples/obj/female02/Female02_bin.js

@@ -9,86 +9,86 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "_03_-_Default1noCulli__03_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "_03_-_Default1noCulli__03_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_03_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_03_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0xee0000,
-	"a_dbg_index" : 1,
-	"a_dbg_name" : "_02_-_Default1noCulli__02_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xee0000,
+	"DbgIndex" : 1,
+	"DbgName" : "_02_-_Default1noCulli__02_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_02_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_02_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0x00ee00,
-	"a_dbg_index" : 2,
-	"a_dbg_name" : "FrontColorNoCullingID__02_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0x00ee00,
+	"DbgIndex" : 2,
+	"DbgName" : "FrontColorNoCullingID__02_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_02_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_02_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0x0000ee,
-	"a_dbg_index" : 3,
-	"a_dbg_name" : "FrontColorNoCullingID__03_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0x0000ee,
+	"DbgIndex" : 3,
+	"DbgName" : "FrontColorNoCullingID__03_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_03_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_03_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0xeeee00,
-	"a_dbg_index" : 4,
-	"a_dbg_name" : "_01_-_Default1noCulli__01_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xeeee00,
+	"DbgIndex" : 4,
+	"DbgName" : "_01_-_Default1noCulli__01_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_01_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_01_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0x00eeee,
-	"a_dbg_index" : 5,
-	"a_dbg_name" : "FrontColorNoCullingID__01_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0x00eeee,
+	"DbgIndex" : 5,
+	"DbgName" : "FrontColorNoCullingID__01_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_01_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_01_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	}],
 

examples/obj/lucy/Lucy100k_bin.js

@@ -9,9 +9,9 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "default"
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "default"
 	}],
 
     'buffers': 'Lucy100k_bin.bin',

examples/obj/male02/Male02_bin.js

@@ -9,72 +9,72 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "male-02-1noCullingID_male-02-1noCulling.JP",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "male-02-1noCullingID_male-02-1noCulling.JP",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "male-02-1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "male-02-1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0xee0000,
-	"a_dbg_index" : 1,
-	"a_dbg_name" : "orig_02_-_Defaul1noCu_orig_02_-_Defaul1noCu",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xee0000,
+	"DbgIndex" : 1,
+	"DbgName" : "orig_02_-_Defaul1noCu_orig_02_-_Defaul1noCu",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "orig_02_-_Defaul1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "orig_02_-_Defaul1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0x00ee00,
-	"a_dbg_index" : 2,
-	"a_dbg_name" : "FrontColorNoCullingID_orig_02_-_Defaul1noCu",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0x00ee00,
+	"DbgIndex" : 2,
+	"DbgName" : "FrontColorNoCullingID_orig_02_-_Defaul1noCu",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "orig_02_-_Defaul1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "orig_02_-_Defaul1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0x0000ee,
-	"a_dbg_index" : 3,
-	"a_dbg_name" : "_01_-_Default1noCulli__01_-_Default1noCulli",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0x0000ee,
+	"DbgIndex" : 3,
+	"DbgName" : "_01_-_Default1noCulli__01_-_Default1noCulli",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "_01_-_Default1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "_01_-_Default1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	},
 
 	{
-	"a_dbg_color" : 0xeeee00,
-	"a_dbg_index" : 4,
-	"a_dbg_name" : "FrontColorNoCullingID_male-02-1noCulling.JP",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
-	"col_specular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
+	"DbgColor" : 0xeeee00,
+	"DbgIndex" : 4,
+	"DbgName" : "FrontColorNoCullingID_male-02-1noCulling.JP",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.80000000000000004, 0.80000000000000004, 0.80000000000000004],
+	"colorSpecular" : [0.16500000000000001, 0.16500000000000001, 0.16500000000000001],
 	"illumination" : 2,
-	"map_diffuse" : "male-02-1noCulling.JPG",
-	"optical_density" : 1.0,
-	"specular_coef" : 154.901961,
+	"mapDiffuse" : "male-02-1noCulling.JPG",
+	"opticalDensity" : 1.0,
+	"specularCoef" : 154.901961,
 	"transparency" : 1.0
 	}],
 

examples/obj/ninja/NinjaLo_bin.js

@@ -9,9 +9,9 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "default"
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "default"
 	}],
 
     'buffers': 'NinjaLo_bin.bin',

examples/obj/torus/Torus_bin.js

@@ -9,9 +9,9 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "(null)"
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "(null)"
 	}],
 
     'buffers': 'Torus_bin.bin',

examples/obj/walt/WaltHead_bin.js

@@ -9,15 +9,15 @@
 
 var model = {
     'materials': [	{
-	"a_dbg_color" : 0xeeeeee,
-	"a_dbg_index" : 0,
-	"a_dbg_name" : "lambert2SG.001",
-	"col_ambient" : [0.0, 0.0, 0.0],
-	"col_diffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
-	"col_specular" : [0.25, 0.25, 0.25],
+	"DbgColor" : 0xeeeeee,
+	"DbgIndex" : 0,
+	"DbgName" : "lambert2SG.001",
+	"colorAmbient" : [0.0, 0.0, 0.0],
+	"colorDiffuse" : [0.64000000000000001, 0.64000000000000001, 0.64000000000000001],
+	"colorSpecular" : [0.25, 0.25, 0.25],
 	"illumination" : 2,
-	"optical_density" : 1.0,
-	"specular_coef" : 92.156863,
+	"opticalDensity" : 1.0,
+	"specularCoef" : 92.156863,
 	"transparency" : 1.0
 	}],
 

src/extras/io/Loader.js

@@ -987,31 +987,31 @@ THREE.Loader.prototype = {
 				// need to process first faces with uvs
 				// as uvs are indexed by face indices
 				
-				for ( i = 0, l = data.triangles_uv.length; i < l; i+= 7 ) {
+				for ( i = 0, l = data.trianglesUvs.length; i < l; i+= 7 ) {
 
-					add_tri( data.triangles_uv, i );
-					add_uv3( data.triangles_uv, i + 4 );
+					add_tri( data.trianglesUvs, i );
+					add_uv3( data.trianglesUvs, i + 4 );
 
 				}
 
-				for ( i = 0, l = data.triangles_n_uv.length; i < l; i += 10 ) {
+				for ( i = 0, l = data.trianglesNormalsUvs.length; i < l; i += 10 ) {
 
-					add_tri_n( data.triangles_n_uv, i );
-					add_uv3( data.triangles_n_uv, i + 7 );
+					add_tri_n( data.trianglesNormalsUvs, i );
+					add_uv3( data.trianglesNormalsUvs, i + 7 );
 
 				}
 				
-				for ( i = 0, l = data.quads_uv.length; i < l; i += 9 ) {
+				for ( i = 0, l = data.quadsUvs.length; i < l; i += 9 ) {
 
-					add_quad( data.quads_uv, i );
-					add_uv4( data.quads_uv, i + 5 );
+					add_quad( data.quadsUvs, i );
+					add_uv4( data.quadsUvs, i + 5 );
 
 				}
 				
-				for ( i = 0, l = data.quads_n_uv.length; i < l; i += 13 ) {
+				for ( i = 0, l = data.quadsNormalsUvs.length; i < l; i += 13 ) {
 
-					add_quad_n( data.quads_n_uv, i );
-					add_uv4( data.quads_n_uv, i + 9 );
+					add_quad_n( data.quadsNormalsUvs, i );
+					add_uv4( data.quadsNormalsUvs, i + 9 );
 
 				}
 				
@@ -1023,9 +1023,9 @@ THREE.Loader.prototype = {
 
 				}
 
-				for ( i = 0, l = data.triangles_n.length; i < l; i += 7 ) {
+				for ( i = 0, l = data.trianglesNormals.length; i < l; i += 7 ) {
 
-					add_tri_n( data.triangles_n, i );
+					add_tri_n( data.trianglesNormals, i );
 
 				}
 
@@ -1035,9 +1035,9 @@ THREE.Loader.prototype = {
 
 				}
 
-				for ( i = 0, l = data.quads_n.length; i < l; i += 9 ) {
+				for ( i = 0, l = data.quadsNormals.length; i < l; i += 9 ) {
 
-					add_quad_n( data.quads_n, i );
+					add_quad_n( data.quadsNormals, i );
 
 				}
 
@@ -1238,7 +1238,7 @@ THREE.Loader.prototype = {
 		// defaults
 		
 		mtype = "MeshLambertMaterial";
-		mpars = { color: 0xeeeeee, opacity: 1.0, map: null, lightMap: null, vertexColors: m.vertex_colors };
+		mpars = { color: 0xeeeeee, opacity: 1.0, map: null, lightMap: null, vertexColors: m.vertexColors };
 		
 		// parameters from model file
 		
@@ -1248,30 +1248,30 @@ THREE.Loader.prototype = {
 			
 		}
 		
-		if ( m.map_diffuse && texture_path ) {
+		if ( m.mapDiffuse && texture_path ) {
 
 			texture = document.createElement( 'canvas' );
 			mpars.map = new THREE.Texture( texture );
-			load_image( mpars.map, texture_path + "/" + m.map_diffuse );
+			load_image( mpars.map, texture_path + "/" + m.mapDiffuse );
 
-		} else if ( m.col_diffuse ) {
+		} else if ( m.colorDiffuse ) {
 
-			color = ( m.col_diffuse[0] * 255 << 16 ) + ( m.col_diffuse[1] * 255 << 8 ) + m.col_diffuse[2] * 255;
+			color = ( m.colorDiffuse[0] * 255 << 16 ) + ( m.colorDiffuse[1] * 255 << 8 ) + m.colorDiffuse[2] * 255;
 			mpars.color = color;
 			mpars.opacity =  m.transparency;
 
-		} else if ( m.a_dbg_color ) {
+		} else if ( m.DbgColor ) {
 
-			mpars.color = m.a_dbg_color;
+			mpars.color = m.DbgColor;
 
 		}
 
-		if ( m.map_lightmap && texture_path ) {
+		if ( m.mapLightmap && texture_path ) {
 
 			texture = document.createElement( 'canvas' );
 			mpars.lightMap = new THREE.Texture( texture );
 			
-			load_image( mpars.lightMap, texture_path + "/" + m.map_lightmap );			
+			load_image( mpars.lightMap, texture_path + "/" + m.mapLightmap );
 
 		}
 		

utils/exporters/blender/2.49/convert_obj_threejs_slim.py

@@ -162,14 +162,14 @@ var model = {
     'uvs': [%(uvs)s],
 
     'triangles': [%(triangles)s],
-    'triangles_n': [%(triangles_n)s],
-    'triangles_uv': [%(triangles_uv)s],
-    'triangles_n_uv': [%(triangles_n_uv)s],
+    'trianglesUvs': [%(trianglesUvs)s],
+    'trianglesNormals': [%(trianglesNormals)s],
+    'trianglesNormalsUvs': [%(trianglesNormalsUvs)s],
 
     'quads': [%(quads)s],
-    'quads_n': [%(quads_n)s],
-    'quads_uv': [%(quads_uv)s],
-    'quads_n_uv': [%(quads_n_uv)s],
+    'quadsUvs': [%(quadsUvs)s],
+    'quadsNormals': [%(quadsNormals)s],
+    'quadsNormalsUvs': [%(quadsNormalsUvs)s],
 
     'end': (new Date).getTime()
     }
@@ -350,22 +350,22 @@ def parse_mtl(fname):
             # Diffuse color
             # Kd 1.000 1.000 1.000
             if chunks[0] == "Kd" and len(chunks) == 4:
-                materials[identifier]["col_diffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorDiffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Ambient color
             # Ka 1.000 1.000 1.000
             if chunks[0] == "Ka" and len(chunks) == 4:
-                materials[identifier]["col_ambient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorAmbient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular color
             # Ks 1.000 1.000 1.000
             if chunks[0] == "Ks" and len(chunks) == 4:
-                materials[identifier]["col_specular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorSpecular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular coefficient
             # Ns 154.000
             if chunks[0] == "Ns" and len(chunks) == 2:
-                materials[identifier]["specular_coef"] = float(chunks[1])
+                materials[identifier]["specularCoef"] = float(chunks[1])
 
             # Transparency
             # Tr 0.9 or d 0.9
@@ -378,32 +378,32 @@ def parse_mtl(fname):
             # Optical density
             # Ni 1.0
             if chunks[0] == "Ni" and len(chunks) == 2:
-                materials[identifier]["optical_density"] = float(chunks[1])
+                materials[identifier]["opticalDensity"] = float(chunks[1])
 
             # Diffuse texture
             # map_Kd texture_diffuse.jpg
             if chunks[0] == "map_Kd" and len(chunks) == 2:
-                materials[identifier]["map_diffuse"] = chunks[1]
+                materials[identifier]["mapDiffuse"] = chunks[1]
 
             # Ambient texture
             # map_Ka texture_ambient.jpg
             if chunks[0] == "map_Ka" and len(chunks) == 2:
-                materials[identifier]["map_ambient"] = chunks[1]
+                materials[identifier]["mapAmbient"] = chunks[1]
 
             # Specular texture
             # map_Ks texture_specular.jpg
             if chunks[0] == "map_Ks" and len(chunks) == 2:
-                materials[identifier]["map_specular"] = chunks[1]
+                materials[identifier]["mapSpecular"] = chunks[1]
 
             # Alpha texture
             # map_d texture_alpha.png
             if chunks[0] == "map_d" and len(chunks) == 2:
-                materials[identifier]["map_alpha"] = chunks[1]
+                materials[identifier]["mapAlpha"] = chunks[1]
 
             # Bump texture
             # map_bump texture_bump.jpg or bump texture_bump.jpg
             if (chunks[0] == "map_bump" or chunks[0] == "bump") and len(chunks) == 2:
-                materials[identifier]["map_bump"] = chunks[1]
+                materials[identifier]["mapBump"] = chunks[1]
 
             # Illumination
             # illum 2
@@ -663,9 +663,9 @@ def generate_materials(mtl, materials):
         #  materials should be sorted according to how
         #  they appeared in OBJ file (for the first time)
         #  this index is identifier used in face definitions
-        mtl[m]['a_dbg_name'] = m
-        mtl[m]['a_dbg_index'] = index
-        mtl[m]['a_dbg_color'] = generate_color(index)
+        mtl[m]['DbgName'] = m
+        mtl[m]['DbgIndex'] = index
+        mtl[m]['DbgColor'] = generate_color(index)
         
         mtl_raw = ",\n".join(['\t"%s" : %s' % (n, value2string(v)) for n,v in sorted(mtl[m].items())])
         mtl_string = "\t{\n%s\n\t}" % mtl_raw
@@ -681,9 +681,9 @@ def generate_mtl(materials):
     for m in materials:
         index = materials[m]
         mtl[m] = {
-            'a_dbg_name': m,
-            'a_dbg_index': index,
-            'a_dbg_color': generate_color(index)
+            'DbgName': m,
+            'DbgIndex': index,
+            'DbgColor': generate_color(index)
         }
     return mtl
     
@@ -809,13 +809,13 @@ def convert_ascii(infile, outfile):
     "name"          : get_name(outfile),
     "vertices"      : ",".join(generate_vertex(v) for v in vertices),
     "triangles"     : ",".join(generate_triangle(f) for f in sfaces['triangles_flat']),
-    "triangles_n"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
-    "triangles_uv"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
-    "triangles_n_uv": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
+    "trianglesUvs"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
+    "trianglesNormals"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
+    "trianglesNormalsUvs": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
     "quads"         : ",".join(generate_quad(f) for f in sfaces['quads_flat']),
-    "quads_n"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
-    "quads_uv"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
-    "quads_n_uv"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
+    "quadsUvs"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
+    "quadsNormals"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
+    "quadsNormalsUvs"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
     "uvs"           : ",".join(generate_uv(uv) for uv in uvs),
     "normals"       : normals_string,
     

utils/exporters/blender/2.56/scripts/op/io_mesh_threejs/export_threejs.py

@@ -74,14 +74,14 @@ var model = {
     'uvs': [%(uvs)s],
 
     'triangles': [%(triangles)s],
-    'triangles_n': [%(triangles_n)s],
-    'triangles_uv': [%(triangles_uv)s],
-    'triangles_n_uv': [%(triangles_n_uv)s],
+    'trianglesUvs': [%(trianglesUvs)s],
+    'trianglesNormals': [%(trianglesNormals)s],
+    'trianglesNormalsUvs': [%(trianglesNormalsUvs)s],
 
     'quads': [%(quads)s],
-    'quads_n': [%(quads_n)s],
-    'quads_uv': [%(quads_uv)s],
-    'quads_n_uv': [%(quads_n_uv)s],
+    'quadsUvs': [%(quadsUvs)s],
+    'quadsNormals': [%(quadsNormals)s],
+    'quadsNormalsUvs': [%(quadsNormalsUvs)s],
 
     'end': (new Date).getTime()
 
@@ -464,10 +464,10 @@ def generate_mtl(materials):
     for m in materials:
         index = materials[m]
         mtl[m] = {
-            'a_dbg_name': m,
-            'a_dbg_index': index,
-            'a_dbg_color': generate_color(index),
-            'vertex_colors' : False
+            'DbgName': m,
+            'DbgIndex': index,
+            'DbgColor': generate_color(index),
+            'vertexColors' : False
         }
     return mtl
 
@@ -490,10 +490,10 @@ def generate_materials(mtl, materials, use_colors):
         #  materials should be sorted according to how
         #  they appeared in OBJ file (for the first time)
         #  this index is identifier used in face definitions
-        mtl[m]['a_dbg_name'] = m
-        mtl[m]['a_dbg_index'] = index
-        mtl[m]['a_dbg_color'] = generate_color(index)
-        mtl[m]['vertex_colors'] = use_colors
+        mtl[m]['DbgName'] = m
+        mtl[m]['DbgIndex'] = index
+        mtl[m]['DbgColor'] = generate_color(index)
+        mtl[m]['vertexColors'] = use_colors
 
         mtl_raw = ",\n".join(['\t"%s" : %s' % (n, value2string(v)) for n,v in sorted(mtl[m].items())])
         mtl_string = "\t{\n%s\n\t}" % mtl_raw
@@ -510,15 +510,15 @@ def extract_materials(mesh, scene):
             materials[m.name] = {}
             material = materials[m.name]
             
-            material['col_diffuse'] = [m.diffuse_intensity * m.diffuse_color[0],
+            material['colorDiffuse'] = [m.diffuse_intensity * m.diffuse_color[0],
                                        m.diffuse_intensity * m.diffuse_color[1],
                                        m.diffuse_intensity * m.diffuse_color[2]]
 
-            material['col_specular'] = [m.specular_intensity * m.specular_color[0],
+            material['colorSpecular'] = [m.specular_intensity * m.specular_color[0],
                                         m.specular_intensity * m.specular_color[1],
                                         m.specular_intensity * m.specular_color[2]]
 
-            material['col_ambient'] = [m.ambient * world.ambient_color[0],
+            material['colorAmbient'] = [m.ambient * world.ambient_color[0],
                                        m.ambient * world.ambient_color[1],
                                        m.ambient * world.ambient_color[2]]
 
@@ -527,13 +527,13 @@ def extract_materials(mesh, scene):
             # not sure about mapping values to Blinn-Phong shader
             # Blender uses INT from [1,511] with default 0
             # http://www.blender.org/documentation/blender_python_api_2_54_0/bpy.types.Material.html#bpy.types.Material.specular_hardness
-            material["specular_coef"] = m.specular_hardness
+            material["specularCoef"] = m.specular_hardness
 
             if m.active_texture and m.active_texture.type == 'IMAGE':
                 fn = bpy.path.abspath(m.active_texture.image.filepath)
                 fn = os.path.normpath(fn)
                 fn_strip = os.path.basename(fn)
-                material['map_diffuse'] = fn_strip
+                material['mapDiffuse'] = fn_strip
                 
             if m.specular_intensity > 0.0 and (m.specular_color[0] > 0 or m.specular_color[1] > 0 or m.specular_color[2] > 0):
                 material['shading'] = "Phong"
@@ -590,14 +590,14 @@ def generate_ascii_model(mesh, scene, use_normals, use_colors, use_uv_coords, al
     "vertices"      : ",".join(generate_vertex(v) for v in vertices),
 
     "triangles"     : ",".join(generate_triangle(f) for f in sfaces['triangles_flat']),
-    "triangles_n"   : ",".join(generate_triangle_n(f, normals, mesh) for f in sfaces['triangles_smooth']),
-    "triangles_uv"  : ",".join(generate_triangle_uv(f, uvs, mesh) for f in sfaces['triangles_flat_uv']),
-    "triangles_n_uv": ",".join(generate_triangle_n_uv(f, normals, uvs, mesh) for f in sfaces['triangles_smooth_uv']),
+    "trianglesUvs"  : ",".join(generate_triangle_uv(f, uvs, mesh) for f in sfaces['triangles_flat_uv']),
+    "trianglesNormals"   : ",".join(generate_triangle_n(f, normals, mesh) for f in sfaces['triangles_smooth']),
+    "trianglesNormalsUvs": ",".join(generate_triangle_n_uv(f, normals, uvs, mesh) for f in sfaces['triangles_smooth_uv']),
 
     "quads"         : ",".join(generate_quad(f) for f in sfaces['quads_flat']),
-    "quads_n"       : ",".join(generate_quad_n(f, normals, mesh) for f in sfaces['quads_smooth']),
-    "quads_uv"      : ",".join(generate_quad_uv(f, uvs, mesh) for f in sfaces['quads_flat_uv']),
-    "quads_n_uv"    : ",".join(generate_quad_n_uv(f, normals, uvs, mesh) for f in sfaces['quads_smooth_uv']),
+    "quadsUvs"      : ",".join(generate_quad_uv(f, uvs, mesh) for f in sfaces['quads_flat_uv']),
+    "quadsNormals"       : ",".join(generate_quad_n(f, normals, mesh) for f in sfaces['quads_smooth']),
+    "quadsNormalsUvs"    : ",".join(generate_quad_n_uv(f, normals, uvs, mesh) for f in sfaces['quads_smooth_uv']),
 
     "uvs"           : generate_uvs(uvs, use_uv_coords),
     "normals"       : generate_normals(normals, use_normals),

utils/exporters/cinema4d/convert_obj_threejs_slim.py

@@ -162,14 +162,14 @@ var model = {
     'uvs': [%(uvs)s],
 
     'triangles': [%(triangles)s],
-    'triangles_n': [%(triangles_n)s],
-    'triangles_uv': [%(triangles_uv)s],
-    'triangles_n_uv': [%(triangles_n_uv)s],
+    'trianglesUvs': [%(trianglesUvs)s],
+    'trianglesNormals': [%(trianglesNormals)s],
+    'trianglesNormalsUvs': [%(trianglesNormalsUvs)s],
 
     'quads': [%(quads)s],
-    'quads_n': [%(quads_n)s],
-    'quads_uv': [%(quads_uv)s],
-    'quads_n_uv': [%(quads_n_uv)s],
+    'quadsUvs': [%(quadsUvs)s],
+    'quadsNormals': [%(quadsNormals)s],
+    'quadsNormalsUvs': [%(quadsNormalsUvs)s],
 
     'end': (new Date).getTime()
     }
@@ -350,22 +350,22 @@ def parse_mtl(fname):
             # Diffuse color
             # Kd 1.000 1.000 1.000
             if chunks[0] == "Kd" and len(chunks) == 4:
-                materials[identifier]["col_diffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorDiffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Ambient color
             # Ka 1.000 1.000 1.000
             if chunks[0] == "Ka" and len(chunks) == 4:
-                materials[identifier]["col_ambient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorAmbient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular color
             # Ks 1.000 1.000 1.000
             if chunks[0] == "Ks" and len(chunks) == 4:
-                materials[identifier]["col_specular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorSpecular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular coefficient
             # Ns 154.000
             if chunks[0] == "Ns" and len(chunks) == 2:
-                materials[identifier]["specular_coef"] = float(chunks[1])
+                materials[identifier]["specularCoef"] = float(chunks[1])
 
             # Transparency
             # Tr 0.9 or d 0.9
@@ -378,32 +378,32 @@ def parse_mtl(fname):
             # Optical density
             # Ni 1.0
             if chunks[0] == "Ni" and len(chunks) == 2:
-                materials[identifier]["optical_density"] = float(chunks[1])
+                materials[identifier]["opticalDensity"] = float(chunks[1])
 
             # Diffuse texture
             # map_Kd texture_diffuse.jpg
             if chunks[0] == "map_Kd" and len(chunks) == 2:
-                materials[identifier]["map_diffuse"] = chunks[1]
+                materials[identifier]["mapDiffuse"] = chunks[1]
 
             # Ambient texture
             # map_Ka texture_ambient.jpg
             if chunks[0] == "map_Ka" and len(chunks) == 2:
-                materials[identifier]["map_ambient"] = chunks[1]
+                materials[identifier]["mapAmbient"] = chunks[1]
 
             # Specular texture
             # map_Ks texture_specular.jpg
             if chunks[0] == "map_Ks" and len(chunks) == 2:
-                materials[identifier]["map_specular"] = chunks[1]
+                materials[identifier]["mapSpecular"] = chunks[1]
 
             # Alpha texture
             # map_d texture_alpha.png
             if chunks[0] == "map_d" and len(chunks) == 2:
-                materials[identifier]["map_alpha"] = chunks[1]
+                materials[identifier]["mapAlpha"] = chunks[1]
 
             # Bump texture
             # map_bump texture_bump.jpg or bump texture_bump.jpg
             if (chunks[0] == "map_bump" or chunks[0] == "bump") and len(chunks) == 2:
-                materials[identifier]["map_bump"] = chunks[1]
+                materials[identifier]["mapBump"] = chunks[1]
 
             # Illumination
             # illum 2
@@ -663,9 +663,9 @@ def generate_materials(mtl, materials):
         #  materials should be sorted according to how
         #  they appeared in OBJ file (for the first time)
         #  this index is identifier used in face definitions
-        mtl[m]['a_dbg_name'] = m
-        mtl[m]['a_dbg_index'] = index
-        mtl[m]['a_dbg_color'] = generate_color(index)
+        mtl[m]['DbgName'] = m
+        mtl[m]['DbgIndex'] = index
+        mtl[m]['DbgColor'] = generate_color(index)
         
         mtl_raw = ",\n".join(['\t"%s" : %s' % (n, value2string(v)) for n,v in sorted(mtl[m].items())])
         mtl_string = "\t{\n%s\n\t}" % mtl_raw
@@ -681,9 +681,9 @@ def generate_mtl(materials):
     for m in materials:
         index = materials[m]
         mtl[m] = {
-            'a_dbg_name': m,
-            'a_dbg_index': index,
-            'a_dbg_color': generate_color(index)
+            'DbgName': m,
+            'DbgIndex': index,
+            'DbgColor': generate_color(index)
         }
     return mtl
     
@@ -809,13 +809,13 @@ def convert_ascii(infile, outfile):
     "name"          : get_name(outfile),
     "vertices"      : ",".join(generate_vertex(v) for v in vertices),
     "triangles"     : ",".join(generate_triangle(f) for f in sfaces['triangles_flat']),
-    "triangles_n"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
-    "triangles_uv"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
-    "triangles_n_uv": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
+    "trianglesUvs"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
+    "trianglesNormals"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
+    "trianglesNormalsUvs": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
     "quads"         : ",".join(generate_quad(f) for f in sfaces['quads_flat']),
-    "quads_n"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
-    "quads_uv"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
-    "quads_n_uv"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
+    "quadsUvs"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
+    "quadsNormals"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
+    "quadsNormalsUvs"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
     "uvs"           : ",".join(generate_uv(uv) for uv in uvs),
     "normals"       : normals_string,
     

utils/exporters/convert_obj_threejs_slim.py

@@ -162,14 +162,14 @@ var model = {
     'uvs': [%(uvs)s],
 
     'triangles': [%(triangles)s],
-    'triangles_n': [%(triangles_n)s],
-    'triangles_uv': [%(triangles_uv)s],
-    'triangles_n_uv': [%(triangles_n_uv)s],
+    'trianglesUvs': [%(trianglesUvs)s],
+    'trianglesNormals': [%(trianglesNormals)s],
+    'trianglesNormalsUvs': [%(trianglesNormalsUvs)s],
 
     'quads': [%(quads)s],
-    'quads_n': [%(quads_n)s],
-    'quads_uv': [%(quads_uv)s],
-    'quads_n_uv': [%(quads_n_uv)s],
+    'quadsUvs': [%(quadsUvs)s],
+    'quadsNormals': [%(quadsNormals)s],
+    'quadsNormalsUvs': [%(quadsNormalsUvs)s],
 
     'end': (new Date).getTime()
     }
@@ -350,22 +350,22 @@ def parse_mtl(fname):
             # Diffuse color
             # Kd 1.000 1.000 1.000
             if chunks[0] == "Kd" and len(chunks) == 4:
-                materials[identifier]["col_diffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorDiffuse"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Ambient color
             # Ka 1.000 1.000 1.000
             if chunks[0] == "Ka" and len(chunks) == 4:
-                materials[identifier]["col_ambient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorAmbient"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular color
             # Ks 1.000 1.000 1.000
             if chunks[0] == "Ks" and len(chunks) == 4:
-                materials[identifier]["col_specular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
+                materials[identifier]["colorSpecular"] = [float(chunks[1]), float(chunks[2]), float(chunks[3])]
 
             # Specular coefficient
             # Ns 154.000
             if chunks[0] == "Ns" and len(chunks) == 2:
-                materials[identifier]["specular_coef"] = float(chunks[1])
+                materials[identifier]["specularCoef"] = float(chunks[1])
 
             # Transparency
             # Tr 0.9 or d 0.9
@@ -378,32 +378,32 @@ def parse_mtl(fname):
             # Optical density
             # Ni 1.0
             if chunks[0] == "Ni" and len(chunks) == 2:
-                materials[identifier]["optical_density"] = float(chunks[1])
+                materials[identifier]["opticalDensity"] = float(chunks[1])
 
             # Diffuse texture
             # map_Kd texture_diffuse.jpg
             if chunks[0] == "map_Kd" and len(chunks) == 2:
-                materials[identifier]["map_diffuse"] = chunks[1]
+                materials[identifier]["mapDiffuse"] = chunks[1]
 
             # Ambient texture
             # map_Ka texture_ambient.jpg
             if chunks[0] == "map_Ka" and len(chunks) == 2:
-                materials[identifier]["map_ambient"] = chunks[1]
+                materials[identifier]["mapAmbient"] = chunks[1]
 
             # Specular texture
             # map_Ks texture_specular.jpg
             if chunks[0] == "map_Ks" and len(chunks) == 2:
-                materials[identifier]["map_specular"] = chunks[1]
+                materials[identifier]["mapSpecular"] = chunks[1]
 
             # Alpha texture
             # map_d texture_alpha.png
             if chunks[0] == "map_d" and len(chunks) == 2:
-                materials[identifier]["map_alpha"] = chunks[1]
+                materials[identifier]["mapAlpha"] = chunks[1]
 
             # Bump texture
             # map_bump texture_bump.jpg or bump texture_bump.jpg
             if (chunks[0] == "map_bump" or chunks[0] == "bump") and len(chunks) == 2:
-                materials[identifier]["map_bump"] = chunks[1]
+                materials[identifier]["mapBump"] = chunks[1]
 
             # Illumination
             # illum 2
@@ -663,9 +663,9 @@ def generate_materials(mtl, materials):
         #  materials should be sorted according to how
         #  they appeared in OBJ file (for the first time)
         #  this index is identifier used in face definitions
-        mtl[m]['a_dbg_name'] = m
-        mtl[m]['a_dbg_index'] = index
-        mtl[m]['a_dbg_color'] = generate_color(index)
+        mtl[m]['DbgName'] = m
+        mtl[m]['DbgIndex'] = index
+        mtl[m]['DbgColor'] = generate_color(index)
         
         mtl_raw = ",\n".join(['\t"%s" : %s' % (n, value2string(v)) for n,v in sorted(mtl[m].items())])
         mtl_string = "\t{\n%s\n\t}" % mtl_raw
@@ -681,9 +681,9 @@ def generate_mtl(materials):
     for m in materials:
         index = materials[m]
         mtl[m] = {
-            'a_dbg_name': m,
-            'a_dbg_index': index,
-            'a_dbg_color': generate_color(index)
+            'DbgName': m,
+            'DbgIndex': index,
+            'DbgColor': generate_color(index)
         }
     return mtl
     
@@ -809,13 +809,13 @@ def convert_ascii(infile, outfile):
     "name"          : get_name(outfile),
     "vertices"      : ",".join(generate_vertex(v) for v in vertices),
     "triangles"     : ",".join(generate_triangle(f) for f in sfaces['triangles_flat']),
-    "triangles_n"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
-    "triangles_uv"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
-    "triangles_n_uv": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
+    "trianglesUvs"  : ",".join(generate_triangle_uv(f) for f in sfaces['triangles_flat_uv']),
+    "trianglesNormals"   : ",".join(generate_triangle_n(f) for f in sfaces['triangles_smooth']),
+    "trianglesNormalsUvs": ",".join(generate_triangle_n_uv(f) for f in sfaces['triangles_smooth_uv']),
     "quads"         : ",".join(generate_quad(f) for f in sfaces['quads_flat']),
-    "quads_n"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
-    "quads_uv"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
-    "quads_n_uv"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
+    "quadsUvs"      : ",".join(generate_quad_uv(f) for f in sfaces['quads_flat_uv']),
+    "quadsNormals"       : ",".join(generate_quad_n(f) for f in sfaces['quads_smooth']),
+    "quadsNormalsUvs"    : ",".join(generate_quad_n_uv(f) for f in sfaces['quads_smooth_uv']),
     "uvs"           : ",".join(generate_uv(uv) for uv in uvs),
     "normals"       : normals_string,
     

utils/exporters/fbx/convert_fbx_three.py

@@ -289,14 +289,14 @@ var model = {
     'uvs2': [%(uvs2)s],
 
     'triangles': [%(triangles)s],
-    'triangles_n': [%(triangles_n)s],
-    'triangles_uv': [%(triangles_uv)s],
-    'triangles_n_uv': [%(triangles_n_uv)s],
+    'trianglesUvs': [%(trianglesUvs)s],
+    'trianglesNormals': [%(trianglesNormals)s],
+    'trianglesNormalsUvs': [%(trianglesNormalsUvs)s],
 
     'quads': [%(quads)s],
-    'quads_n': [%(quads_n)s],
-    'quads_uv': [%(quads_uv)s],
-    'quads_n_uv': [%(quads_n_uv)s],
+    'quadsUvs': [%(quadsUvs)s],
+    'quadsNormals': [%(quadsNormals)s],
+    'quadsNormalsUvs': [%(quadsNormalsUvs)s],
 
     'end': (new Date).getTime()
     }
@@ -1274,16 +1274,16 @@ def generate_materials_scene(data):
                     parameters += ", shininess: %f" % material["shininess"]
 
                 # TODO: proper handling of textures
-                color_map = get_material_texture(material_index, mesh["data"]["textures"], "DiffuseColor")
-                light_map = get_material_texture(material_index, mesh["data"]["textures"], "AmbientColor")
-                bump_map  = get_material_texture(material_index, mesh["data"]["textures"], "Bump")
+                colorMap = get_material_texture(material_index, mesh["data"]["textures"], "DiffuseColor")
+                lightMap = get_material_texture(material_index, mesh["data"]["textures"], "AmbientColor")
+                bumpMap  = get_material_texture(material_index, mesh["data"]["textures"], "Bump")
                 
                 if map:
-                    parameters += ", map: %s" % generate_string(color_map[0]["info"]["name"])
-                if light_map:
-                    parameters += ", light_map: %s" % generate_string(light_map[0]["info"]["name"])
-                if bump_map:
-                    parameters += ", bump_map: %s" % generate_string(bump_map[0]["info"]["name"])
+                    parameters += ", map: %s" % generate_string(colorMap[0]["info"]["name"])
+                if lightMap:
+                    parameters += ", lightMap: %s" % generate_string(lightMap[0]["info"]["name"])
+                if bumpMap:
+                    parameters += ", bumpMap: %s" % generate_string(bumpMap[0]["info"]["name"])
                 
                 material_string = TEMPLATE_MATERIAL_SCENE % {
                 "material_id" : generate_string(material_id),
@@ -1396,25 +1396,25 @@ def value2string(v):
 
 def generate_material_model(material, index):
     m = {
-    'a_dbg_name'    :generate_string(material["name"]),
-    'a_dbg_index'   :index,
-    'a_dbg_color'   :generate_color(index),
+    'DbgName'    :generate_string(material["name"]),
+    'DbgIndex'   :index,
+    'DbgColor'   :generate_color(index),
     "shading"       :generate_string(material["shading_model"]),
     "opacity"       : material["opacity"]
     }
     
     if material["shading_model"] in ["Lambert", "Phong"]:
-        m["col_ambient"] = material["ambient"]
-        m["col_diffuse"] = material["diffuse"]
+        m["colorAmbient"] = material["ambient"]
+        m["colorDiffuse"] = material["diffuse"]
         m["col_emissive"] = material["emissive"]
         
     if material["shading_model"] in ["Phong"]:
-        m["col_specular"] = material["specular"]
+        m["colorSpecular"] = material["specular"]
         m["shininess"] = material["shininess"]
         
     if not MATERIALS_IN_SCENE:
-        conditional_set(m, "map_diffuse", material.get("map_diffuse", 0))
-        conditional_set(m, "map_lightmap", material.get("map_lightmap", 0))    
+        conditional_set(m, "mapDiffuse", material.get("mapDiffuse", 0))
+        conditional_set(m, "mapLightmap", material.get("mapLightmap", 0))    
         
     mtl_raw = ",\n".join(['\t"%s" : %s' % (n, value2string(v)) for n,v in sorted(m.items())])
     mtl_string = "\t{\n%s\n\t}" % mtl_raw
@@ -1444,14 +1444,14 @@ def generate_ascii_model(data):
         
 
     triangles = []
-    triangles_n = []
-    triangles_uv = []
-    triangles_n_uv = []
+    trianglesUvs = []
+    trianglesNormals = []
+    trianglesNormalsUvs = []
 
     quads = []
-    quads_n = []
-    quads_uv = []
-    quads_n_uv = []
+    quadsUvs = []
+    quadsNormals = []
+    quadsNormalsUvs = []
 
     indices_vertex = data["faces"]["indices_vertex"]
     for vi in range(len(indices_vertex)):
@@ -1480,24 +1480,24 @@ def generate_ascii_model(data):
         if len(vertex_index) == 3:
             if normals:
                 if uvs:
-                    where = triangles_n_uv
+                    where = trianglesNormalsUvs
                 else:
-                    where = triangles_n
+                    where = trianglesNormals
             else:
                 if uvs:
-                    where = triangles_uv
+                    where = trianglesUvs
                 else:
                     where = triangles
                     
         elif len(vertex_index) == 4:
             if normals:
                 if uvs:
-                    where = quads_n_uv
+                    where = quadsNormalsUvs
                 else:
-                    where = quads_n
+                    where = quadsNormals
             else:
                 if uvs:
-                    where = quads_uv
+                    where = quadsUvs
                 else:
                     where = quads
             
@@ -1522,14 +1522,14 @@ def generate_ascii_model(data):
     "uvs2"      : ",".join(generate_uv(u) for u in uvs2),
 
     "triangles"     : ",".join(generate_triangle(f) for f in triangles),
-    "triangles_n"   : ",".join(generate_triangle_n(f) for f in triangles_n),
-    "triangles_uv"  : ",".join(generate_triangle_uv(f) for f in triangles_uv),
-    "triangles_n_uv": ",".join(generate_triangle_n_uv(f) for f in triangles_n_uv),
+    "trianglesUvs"  : ",".join(generate_triangle_uv(f) for f in trianglesUvs),
+    "trianglesNormals"   : ",".join(generate_triangle_n(f) for f in trianglesNormals),
+    "trianglesNormalsUvs": ",".join(generate_triangle_n_uv(f) for f in trianglesNormalsUvs),
         
     "quads"         : ",".join(generate_quad(f) for f in quads),
-    "quads_n"       : ",".join(generate_quad_n(f) for f in quads_n),
-    "quads_uv"      : ",".join(generate_quad_uv(f) for f in quads_uv),
-    "quads_n_uv"    : ",".join(generate_quad_n_uv(f) for f in quads_n_uv)
+    "quadsUvs"      : ",".join(generate_quad_uv(f) for f in quadsUvs),
+    "quadsNormals"       : ",".join(generate_quad_n(f) for f in quadsNormals),
+    "quadsNormalsUvs"    : ",".join(generate_quad_n_uv(f) for f in quadsNormalsUvs)
     }
     
     return text