/lenasys/0.1

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/0.1

« back to all changes in this revision

Viewing changes to trunk/WebGL and Benchmarking/webgl-helpers.js

  • Committer: Henrik G.
  • Date: 2013-03-26 23:42:29 UTC
  • Revision ID: henrik.gustavsson@his.se-20130326234229-hkq5am6szg5g2akr
Added slider library

Show diffs side-by-side

added added

removed removed

Lines of Context:
trunk/WebGL and Benchmarking/webgl-helpers.js
1
 
//----------------------------------------------------------
2
 
// helper Globals
3
 
//----------------------------------------------------------            
4
 
 
5
 
var shaderProgram;
6
 
var gl;
7
 
 
8
 
var fps = 0;
9
 
var fpsmax = 0;
10
 
var timecount = 0;
11
 
var fpssum = 0;
12
 
var fpscount = 1;
13
 
var benchtime = 0;
14
 
 
15
 
var username = "";
16
 
 
17
 
//----------------------------------------------------------
18
 
// getShader collects shader and compiles it. Errors are printed in alert
19
 
//----------------------------------------------------------            
20
 
 
21
 
function getShader(gl, id) {
22
 
        var shaderScript = document.getElementById(id);
23
 
        if (!shaderScript) {
24
 
                return null;
25
 
        }
26
 
 
27
 
        var str = "";
28
 
        var k = shaderScript.firstChild;
29
 
        while (k) {
30
 
                if (k.nodeType == 3) {
31
 
                        str += k.textContent;
32
 
                }
33
 
                k = k.nextSibling;
34
 
        }
35
 
 
36
 
        var shader;
37
 
        if (shaderScript.type == "x-shader/x-fragment") {
38
 
                shader = gl.createShader(gl.FRAGMENT_SHADER);
39
 
        } else if (shaderScript.type == "x-shader/x-vertex") {
40
 
                shader = gl.createShader(gl.VERTEX_SHADER);
41
 
        } else {
42
 
                return null;
43
 
        }
44
 
 
45
 
        gl.shaderSource(shader, str);
46
 
        gl.compileShader(shader);
47
 
 
48
 
        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
49
 
                alert(gl.getShaderInfoLog(shader));
50
 
                return null;
51
 
        }
52
 
 
53
 
        return shader;
54
 
}
55
 
 
56
 
//----------------------------------------------------------
57
 
// Matrix stack variables
58
 
//----------------------------------------------------------            
59
 
 
60
 
var mvMatrix = mat4.create();
61
 
var mvMatrixStack = [];
62
 
var pMatrix = mat4.create();
63
 
 
64
 
//----------------------------------------------------------
65
 
// Push Matrix
66
 
//----------------------------------------------------------            
67
 
 
68
 
function mvPushMatrix() {
69
 
        var copy = mat4.create();
70
 
        mat4.set(mvMatrix, copy);
71
 
        mvMatrixStack.push(copy);
72
 
}
73
 
 
74
 
//----------------------------------------------------------
75
 
// Pop Matrix
76
 
//----------------------------------------------------------            
77
 
 
78
 
function mvPopMatrix() {
79
 
        if (mvMatrixStack.length == 0) {
80
 
                throw "Invalid popMatrix!";
81
 
        }
82
 
        mvMatrix = mvMatrixStack.pop();
83
 
}
84
 
 
85
 
//----------------------------------------------------------
86
 
// Startup webGL and alert if not available
87
 
//----------------------------------------------------------            
88
 
 
89
 
function initGL(canvas) {
90
 
        try {
91
 
                gl = canvas.getContext("experimental-webgl");
92
 
                gl.viewportWidth = canvas.width;
93
 
                gl.viewportHeight = canvas.height;
94
 
        } catch (e) {
95
 
        } 
96
 
 
97
 
        if (!gl) {
98
 
                alert("Could not initialise WebGL, sorry :-(");
99
 
        }
100
 
}
101
 
 
102
 
//----------------------------------------------------------
103
 
// Measure fps and update div if available
104
 
//----------------------------------------------------------            
105
 
 
106
 
function updatefps(elapsed,fpsdiv) {
107
 
        if(!isNaN(elapsed)) {
108
 
                timecount += (elapsed / 1000.0);
109
 
                fpssum += (elapsed / 10.0);                                                                                     
110
 
        } 
111
 
        if(elapsed < 1) {
112
 
                elapsed = 1;
113
 
        } 
114
 
 
115
 
        fpscount++;
116
 
        fps = Math.round((100.0 / (fpssum / fpscount)) * 10.0) / 10.0;
117
 
 
118
 
        if(fps > fpsmax&&timecount > 5.0) {
119
 
                fpsmax = fps;
120
 
        }
121
 
 
122
 
        fpsd = document.getElementById(fpsdiv);
123
 
        if(fpsd != null) {
124
 
                fpsd.innerHTML = fps;
125
 
        }
126
 
 
127
 
}
128
 
 
129
 
//----------------------------------------------------------
130
 
// Sends benchmark every X seconds
131
 
//----------------------------------------------------------            
132
 
 
133
 
function sendbenchmark(delay,app) {
134
 
        // Every 8 seconds send benchmark data to server!
135
 
        if(Math.abs(timecount - benchtime) > delay) {
136
 
                benchtime = timecount;
137
 
                benchmark(username, app, fps, fpsmax, Math.round(timecount * 10.0) / 10.0);
138
 
        }                                                                                                                                                               
139
 
}
140
 
 
141
 
//----------------------------------------------------------
142
 
// Generate benchmark userID
143
 
//----------------------------------------------------------            
144
 
 
145
 
function genID(app) {                                                                                                                                            
146
 
        username = localStorage.getItem("Benchuser"); //Try to fetch username data                                                             
147
 
        if (username == null || username == "") {
148
 
                var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
149
 
                text = "";
150
 
                for(var i = 0; i < 16; i++) {
151
 
                        text += possible.charAt(Math.floor(Math.random() * possible.length));
152
 
                }
153
 
                username =  text;
154
 
                localStorage.setItem("Benchuser", username);
155
 
        }
156
 
 
157
 
        benchmark(username, app, fps, fpsmax, Math.round(timecount * 10.0) / 10.0);                                                                                                                                    
158
 
}                                                                                                                                            
159
 
 
160
 
//----------------------------------------------------------
161
 
// Send benchmark using httpajax.js
162
 
//----------------------------------------------------------            
163
 
 
164
 
function benchmark(username, app, fps, maxfps, runtime) {
165
 
        var paramstr = 'User=' + escape(username);
166
 
        paramstr += "&App=" + escape(app);
167
 
        paramstr += "&Fps=" + escape(fps);              
168
 
        paramstr += "&MaxFps=" + escape(maxfps);                
169
 
        paramstr += "&RunTime=" + escape(runtime);
170
 
        AjaxService("Benchy.php", paramstr);                            
171
 
}                       
 
1
                //----------------------------------------------------------
 
2
                // helper Globals
 
3
          //----------------------------------------------------------          
 
4
 
 
5
    var shaderProgram;
 
6
    var gl;
 
7
 
 
8
    var fps=0;
 
9
    var fpsmax=0;
 
10
    var timecount=0;
 
11
                var fpssum=0;
 
12
                var fpscount=1;
 
13
                var benchtime=0;
 
14
 
 
15
                var username="";
 
16
    
 
17
                //----------------------------------------------------------
 
18
                // getShader collects shader and compiles it. Errors are printed in alert
 
19
          //----------------------------------------------------------          
 
20
 
 
21
    function getShader(gl, id) {
 
22
        var shaderScript = document.getElementById(id);
 
23
        if (!shaderScript) {
 
24
            return null;
 
25
        }
 
26
 
 
27
        var str = "";
 
28
        var k = shaderScript.firstChild;
 
29
        while (k) {
 
30
            if (k.nodeType == 3) {
 
31
                str += k.textContent;
 
32
            }
 
33
            k = k.nextSibling;
 
34
        }
 
35
 
 
36
        var shader;
 
37
        if (shaderScript.type == "x-shader/x-fragment") {
 
38
            shader = gl.createShader(gl.FRAGMENT_SHADER);
 
39
        } else if (shaderScript.type == "x-shader/x-vertex") {
 
40
            shader = gl.createShader(gl.VERTEX_SHADER);
 
41
        } else {
 
42
            return null;
 
43
        }
 
44
 
 
45
        gl.shaderSource(shader, str);
 
46
        gl.compileShader(shader);
 
47
 
 
48
        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
 
49
            alert(gl.getShaderInfoLog(shader));
 
50
            return null;
 
51
        }
 
52
 
 
53
        return shader;
 
54
    }
 
55
 
 
56
                //----------------------------------------------------------
 
57
                // Matrix stack variables
 
58
          //----------------------------------------------------------          
 
59
 
 
60
    var mvMatrix = mat4.create();
 
61
    var mvMatrixStack = [];
 
62
    var pMatrix = mat4.create();
 
63
 
 
64
                //----------------------------------------------------------
 
65
                // Push Matrix
 
66
          //----------------------------------------------------------          
 
67
 
 
68
    function mvPushMatrix() {
 
69
        var copy = mat4.create();
 
70
        mat4.set(mvMatrix, copy);
 
71
        mvMatrixStack.push(copy);
 
72
    }
 
73
 
 
74
                //----------------------------------------------------------
 
75
                // Pop Matrix
 
76
          //----------------------------------------------------------          
 
77
 
 
78
    function mvPopMatrix() {
 
79
        if (mvMatrixStack.length == 0) {
 
80
            throw "Invalid popMatrix!";
 
81
        }
 
82
        mvMatrix = mvMatrixStack.pop();
 
83
    }
 
84
 
 
85
                //----------------------------------------------------------
 
86
                // Startup webGL and alert if not available
 
87
          //----------------------------------------------------------          
 
88
    
 
89
    function initGL(canvas) {
 
90
        try {
 
91
            gl = canvas.getContext("experimental-webgl");
 
92
            gl.viewportWidth = canvas.width;
 
93
            gl.viewportHeight = canvas.height;
 
94
        } catch (e) {
 
95
        }if (!gl){
 
96
            alert("Could not initialise WebGL, sorry :-(");
 
97
        }
 
98
    }
 
99
 
 
100
                //----------------------------------------------------------
 
101
                // Measure fps and update div if available
 
102
          //----------------------------------------------------------          
 
103
 
 
104
                function updatefps(elapsed,fpsdiv)
 
105
                {
 
106
                                if(!isNaN(elapsed)){
 
107
                                                timecount+=(elapsed/1000.0);
 
108
                                                fpssum+=(elapsed/10.0);                                                                                 
 
109
                                } 
 
110
                                if(elapsed<1) elapsed=1;
 
111
                                
 
112
                                fpscount++;
 
113
                                fps=Math.round((100.0/(fpssum/fpscount))*10.0)/10.0;
 
114
                                                                
 
115
                                if(fps>fpsmax&&timecount>5.0) fpsmax=fps;
 
116
 
 
117
                                fpsd=document.getElementById(fpsdiv);
 
118
                                if(fpsd!=null) fpsd.innerHTML=fps;
 
119
 
 
120
                }
 
121
 
 
122
                //----------------------------------------------------------
 
123
                // Sends benchmark every X seconds
 
124
          //----------------------------------------------------------          
 
125
 
 
126
                function sendbenchmark(delay,app)
 
127
                {
 
128
                // Every 8 seconds send benchmark data to server!
 
129
                if(Math.abs(timecount-benchtime)>delay){
 
130
                        benchtime=timecount;
 
131
                                        Benchmark(username,app,fps,fpsmax,Math.round(timecount*10.0)/10.0);
 
132
                                }                                                                                                                                                               
 
133
                }
 
134
                
 
135
                //----------------------------------------------------------
 
136
                // Generate benchmark userID
 
137
          //----------------------------------------------------------          
 
138
                
 
139
                function genID(app)                                                                                                                       
 
140
                {                                                                                                                                            
 
141
                        username = localStorage.getItem("Benchuser"); //Try to fetch username data                                                             
 
142
                        if (username==null||username==""){
 
143
                        var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
144
                                        text="";
 
145
                        for( var i=0; i < 16; i++ ) text += possible.charAt(Math.floor(Math.random() * possible.length));
 
146
                                        username=text;
 
147
                                        localStorage.setItem("Benchuser",username);
 
148
                        }else{
 
149
      }
 
150
     
 
151
      Benchmark(username,app,fps,fpsmax,Math.round(timecount*10.0)/10.0);                                                                                                                                    
 
152
    }                                                                                                                                            
 
153
 
 
154
                //----------------------------------------------------------
 
155
                // Send Benchmark using httpajax.js
 
156
          //----------------------------------------------------------          
 
157
 
 
158
                function Benchmark(username,app,fps,maxfps,runtime)
 
159
                {
 
160
                                var paramstr='User='+escape(username);
 
161
                                paramstr+="&App="+escape(app);
 
162
                                paramstr+="&Fps="+escape(fps);          
 
163
                                paramstr+="&MaxFps="+escape(maxfps);            
 
164
                                paramstr+="&RunTime="+escape(runtime);
 
165
                                AjaxService("Benchy.php",paramstr);                             
 
166
                }                       
 
167
                
 
 
b'\\ No newline at end of file'