Last active
August 24, 2017 17:30
-
-
Save katsube/fcadd23d7c5d24cefd7278104c9429a1 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!DOCTYPE html> | |
<html> | |
<head> | |
<title>Hello, WebVR! - A-Frame</title> | |
<script src="https://aframe.io/releases/0.6.0/aframe.min.js"></script> | |
</head> | |
<body> | |
<a-scene> | |
<!-- 立方体/球/円柱 --> | |
<a-box position="-1 0.5 -3" rotation="0 45 0" color="#4CC3D9"></a-box> | |
<a-sphere position="0 1.25 -5" radius="1.25" color="#EF2D5E"></a-sphere> | |
<a-cylinder position="1 0.75 -3" radius="0.5" height="1.5" color="#FFC65D"></a-cylinder> | |
<!-- 地面 --> | |
<a-plane position="0 0 -4" rotation="-90 0 0" width="4" height="4" color="#7BC8A4"></a-plane> | |
<!-- 空(空間) --> | |
<a-sky color="#ECECEC"></a-sky> | |
</a-scene> | |
</body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!DOCTYPE html> | |
<html> | |
<head> | |
<meta charset="utf-8"> | |
<title>HelloWorld</title> | |
</head> | |
<body> | |
<h1>こんにちは!</h1> | |
<p><img src="image/foo.jpg"></p> | |
</body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!DOCTYPE html> | |
<html> | |
<head> | |
<meta charset="utf-8"> | |
<title>HelloWorld</title> | |
</head> | |
<body> | |
<h1>こんにちは!</h1> | |
<form> | |
<button type="button" id="hello">こんにちは!</button> | |
</form> | |
<script> | |
var hello = document.querySelector("#hello"); | |
hello.addEventListener("click", function(){ | |
alert("hello"); | |
}); | |
</script> | |
</body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!DOCTYPE html> | |
<html> | |
<head> | |
<meta charset="utf-8"> | |
<title>HelloWorld</title> | |
</head> | |
<body> | |
<h1>こんにちは!</h1> | |
<form> | |
<button type="button" id="hello">こんにちは!</button> | |
</form> | |
<script src="https://code.jquery.com/jquery-3.2.1.min.js"></script> | |
<script> | |
$("#hello").on("click", function(){ | |
alert("こんにちは!"); | |
}); | |
</script> | |
</body> | |
</html> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var cubeRotation = 0.0; | |
main(); | |
// | |
// Start here | |
// | |
function main() { | |
const canvas = document.querySelector('#glcanvas'); | |
const gl = canvas.getContext('webgl'); | |
// If we don't have a GL context, give up now | |
if (!gl) { | |
alert('Unable to initialize WebGL. Your browser or machine may not support it.'); | |
return; | |
} | |
// Vertex shader program | |
const vsSource = ` | |
attribute vec4 aVertexPosition; | |
attribute vec4 aVertexColor; | |
uniform mat4 uModelViewMatrix; | |
uniform mat4 uProjectionMatrix; | |
varying lowp vec4 vColor; | |
void main(void) { | |
gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition; | |
vColor = aVertexColor; | |
} | |
`; | |
// Fragment shader program | |
const fsSource = ` | |
varying lowp vec4 vColor; | |
void main(void) { | |
gl_FragColor = vColor; | |
} | |
`; | |
// Initialize a shader program; this is where all the lighting | |
// for the vertices and so forth is established. | |
const shaderProgram = initShaderProgram(gl, vsSource, fsSource); | |
// Collect all the info needed to use the shader program. | |
// Look up which attributes our shader program is using | |
// for aVertexPosition, aVevrtexColor and also | |
// look up uniform locations. | |
const programInfo = { | |
program: shaderProgram, | |
attribLocations: { | |
vertexPosition: gl.getAttribLocation(shaderProgram, 'aVertexPosition'), | |
vertexColor: gl.getAttribLocation(shaderProgram, 'aVertexColor'), | |
}, | |
uniformLocations: { | |
projectionMatrix: gl.getUniformLocation(shaderProgram, 'uProjectionMatrix'), | |
modelViewMatrix: gl.getUniformLocation(shaderProgram, 'uModelViewMatrix'), | |
}, | |
}; | |
// Here's where we call the routine that builds all the | |
// objects we'll be drawing. | |
const buffers = initBuffers(gl); | |
var then = 0; | |
// Draw the scene repeatedly | |
function render(now) { | |
now *= 0.001; // convert to seconds | |
const deltaTime = now - then; | |
then = now; | |
drawScene(gl, programInfo, buffers, deltaTime); | |
requestAnimationFrame(render); | |
} | |
requestAnimationFrame(render); | |
} | |
// | |
// initBuffers | |
// | |
// Initialize the buffers we'll need. For this demo, we just | |
// have one object -- a simple three-dimensional cube. | |
// | |
function initBuffers(gl) { | |
// Create a buffer for the cube's vertex positions. | |
const positionBuffer = gl.createBuffer(); | |
// Select the positionBuffer as the one to apply buffer | |
// operations to from here out. | |
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); | |
// Now create an array of positions for the cube. | |
const positions = [ | |
// Front face | |
-1.0, -1.0, 1.0, | |
1.0, -1.0, 1.0, | |
1.0, 1.0, 1.0, | |
-1.0, 1.0, 1.0, | |
// Back face | |
-1.0, -1.0, -1.0, | |
-1.0, 1.0, -1.0, | |
1.0, 1.0, -1.0, | |
1.0, -1.0, -1.0, | |
// Top face | |
-1.0, 1.0, -1.0, | |
-1.0, 1.0, 1.0, | |
1.0, 1.0, 1.0, | |
1.0, 1.0, -1.0, | |
// Bottom face | |
-1.0, -1.0, -1.0, | |
1.0, -1.0, -1.0, | |
1.0, -1.0, 1.0, | |
-1.0, -1.0, 1.0, | |
// Right face | |
1.0, -1.0, -1.0, | |
1.0, 1.0, -1.0, | |
1.0, 1.0, 1.0, | |
1.0, -1.0, 1.0, | |
// Left face | |
-1.0, -1.0, -1.0, | |
-1.0, -1.0, 1.0, | |
-1.0, 1.0, 1.0, | |
-1.0, 1.0, -1.0, | |
]; | |
// Now pass the list of positions into WebGL to build the | |
// shape. We do this by creating a Float32Array from the | |
// JavaScript array, then use it to fill the current buffer. | |
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW); | |
// Now set up the colors for the faces. We'll use solid colors | |
// for each face. | |
const faceColors = [ | |
[1.0, 1.0, 1.0, 1.0], // Front face: white | |
[1.0, 0.0, 0.0, 1.0], // Back face: red | |
[0.0, 1.0, 0.0, 1.0], // Top face: green | |
[0.0, 0.0, 1.0, 1.0], // Bottom face: blue | |
[1.0, 1.0, 0.0, 1.0], // Right face: yellow | |
[1.0, 0.0, 1.0, 1.0], // Left face: purple | |
]; | |
// Convert the array of colors into a table for all the vertices. | |
var colors = []; | |
for (var j = 0; j < faceColors.length; ++j) { | |
const c = faceColors[j]; | |
// Repeat each color four times for the four vertices of the face | |
colors = colors.concat(c, c, c, c); | |
} | |
const colorBuffer = gl.createBuffer(); | |
gl.bindBuffer(gl.ARRAY_BUFFER, colorBuffer); | |
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(colors), gl.STATIC_DRAW); | |
// Build the element array buffer; this specifies the indices | |
// into the vertex arrays for each face's vertices. | |
const indexBuffer = gl.createBuffer(); | |
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer); | |
// This array defines each face as two triangles, using the | |
// indices into the vertex array to specify each triangle's | |
// position. | |
const indices = [ | |
0, 1, 2, 0, 2, 3, // front | |
4, 5, 6, 4, 6, 7, // back | |
8, 9, 10, 8, 10, 11, // top | |
12, 13, 14, 12, 14, 15, // bottom | |
16, 17, 18, 16, 18, 19, // right | |
20, 21, 22, 20, 22, 23, // left | |
]; | |
// Now send the element array to GL | |
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, | |
new Uint16Array(indices), gl.STATIC_DRAW); | |
return { | |
position: positionBuffer, | |
color: colorBuffer, | |
indices: indexBuffer, | |
}; | |
} | |
// | |
// Draw the scene. | |
// | |
function drawScene(gl, programInfo, buffers, deltaTime) { | |
gl.clearColor(0.0, 0.0, 0.0, 1.0); // Clear to black, fully opaque | |
gl.clearDepth(1.0); // Clear everything | |
gl.enable(gl.DEPTH_TEST); // Enable depth testing | |
gl.depthFunc(gl.LEQUAL); // Near things obscure far things | |
// Clear the canvas before we start drawing on it. | |
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); | |
// Create a perspective matrix, a special matrix that is | |
// used to simulate the distortion of perspective in a camera. | |
// Our field of view is 45 degrees, with a width/height | |
// ratio that matches the display size of the canvas | |
// and we only want to see objects between 0.1 units | |
// and 100 units away from the camera. | |
const fieldOfView = 45 * Math.PI / 180; // in radians | |
const aspect = gl.canvas.clientWidth / gl.canvas.clientHeight; | |
const zNear = 0.1; | |
const zFar = 100.0; | |
const projectionMatrix = mat4.create(); | |
// note: glmatrix.js always has the first argument | |
// as the destination to receive the result. | |
mat4.perspective(projectionMatrix, | |
fieldOfView, | |
aspect, | |
zNear, | |
zFar); | |
// Set the drawing position to the "identity" point, which is | |
// the center of the scene. | |
const modelViewMatrix = mat4.create(); | |
// Now move the drawing position a bit to where we want to | |
// start drawing the square. | |
mat4.translate(modelViewMatrix, // destination matrix | |
modelViewMatrix, // matrix to translate | |
[-0.0, 0.0, -6.0]); // amount to translate | |
mat4.rotate(modelViewMatrix, // destination matrix | |
modelViewMatrix, // matrix to rotate | |
cubeRotation, // amount to rotate in radians | |
[0, 0, 1]); // axis to rotate around (Z) | |
mat4.rotate(modelViewMatrix, // destination matrix | |
modelViewMatrix, // matrix to rotate | |
cubeRotation * .7,// amount to rotate in radians | |
[0, 1, 0]); // axis to rotate around (X) | |
// Tell WebGL how to pull out the positions from the position | |
// buffer into the vertexPosition attribute | |
{ | |
const numComponents = 3; | |
const type = gl.FLOAT; | |
const normalize = false; | |
const stride = 0; | |
const offset = 0; | |
gl.bindBuffer(gl.ARRAY_BUFFER, buffers.position); | |
gl.vertexAttribPointer( | |
programInfo.attribLocations.vertexPosition, | |
numComponents, | |
type, | |
normalize, | |
stride, | |
offset); | |
gl.enableVertexAttribArray( | |
programInfo.attribLocations.vertexPosition); | |
} | |
// Tell WebGL how to pull out the colors from the color buffer | |
// into the vertexColor attribute. | |
{ | |
const numComponents = 4; | |
const type = gl.FLOAT; | |
const normalize = false; | |
const stride = 0; | |
const offset = 0; | |
gl.bindBuffer(gl.ARRAY_BUFFER, buffers.color); | |
gl.vertexAttribPointer( | |
programInfo.attribLocations.vertexColor, | |
numComponents, | |
type, | |
normalize, | |
stride, | |
offset); | |
gl.enableVertexAttribArray( | |
programInfo.attribLocations.vertexColor); | |
} | |
// Tell WebGL which indices to use to index the vertices | |
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffers.indices); | |
// Tell WebGL to use our program when drawing | |
gl.useProgram(programInfo.program); | |
// Set the shader uniforms | |
gl.uniformMatrix4fv( | |
programInfo.uniformLocations.projectionMatrix, | |
false, | |
projectionMatrix); | |
gl.uniformMatrix4fv( | |
programInfo.uniformLocations.modelViewMatrix, | |
false, | |
modelViewMatrix); | |
{ | |
const vertexCount = 36; | |
const type = gl.UNSIGNED_SHORT; | |
const offset = 0; | |
gl.drawElements(gl.TRIANGLES, vertexCount, type, offset); | |
} | |
// Update the rotation for the next draw | |
cubeRotation += deltaTime; | |
} | |
// | |
// Initialize a shader program, so WebGL knows how to draw our data | |
// | |
function initShaderProgram(gl, vsSource, fsSource) { | |
const vertexShader = loadShader(gl, gl.VERTEX_SHADER, vsSource); | |
const fragmentShader = loadShader(gl, gl.FRAGMENT_SHADER, fsSource); | |
// Create the shader program | |
const shaderProgram = gl.createProgram(); | |
gl.attachShader(shaderProgram, vertexShader); | |
gl.attachShader(shaderProgram, fragmentShader); | |
gl.linkProgram(shaderProgram); | |
// If creating the shader program failed, alert | |
if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) { | |
alert('Unable to initialize the shader program: ' + gl.getProgramInfoLog(shaderProgram)); | |
return null; | |
} | |
return shaderProgram; | |
} | |
// | |
// creates a shader of the given type, uploads the source and | |
// compiles it. | |
// | |
function loadShader(gl, type, source) { | |
const shader = gl.createShader(type); | |
// Send the source to the shader object | |
gl.shaderSource(shader, source); | |
// Compile the shader program | |
gl.compileShader(shader); | |
// See if it compiled successfully | |
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) { | |
alert('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(shader)); | |
gl.deleteShader(shader); | |
return null; | |
} | |
return shader; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment