static void http_write_upgrade_response(uv_stream_t* stream)
{
Value* msg = circa_alloc_value();
circa_set_string(msg, "HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: ");
circa_string_append(msg, "(responseKey)");
circa_string_append(msg, "\r\n\r\n");
circa_uv_write(stream, msg, false);
}
void make_server(Stack* stack)
{
Value* ip = circa_input(stack, 0);
Value* port = circa_input(stack, 1);
Value* type = circa_input(stack, 2);
Server* server = new Server();
if (circa_string_equals(type, ":tcp")) {
server->serverType = TCP;
} else if (circa_string_equals(type, ":websock")) {
server->serverType = WEBSOCK;
memset(&server->parser_settings, 0, sizeof(server->parser_settings));
server->parser_settings.on_message_begin = http_on_message_begin;
server->parser_settings.on_url = http_on_url;
server->parser_settings.on_status = http_on_status;
server->parser_settings.on_header_field = http_on_header_field;
server->parser_settings.on_header_value = http_on_header_value;
server->parser_settings.on_headers_complete = http_on_headers_complete;
server->parser_settings.on_body = http_on_body;
server->parser_settings.on_message_complete = http_on_message_complete;
} else {
Value msg;
circa_set_string(&msg, "Unrecognized server type: ");
circa_string_append_val(&msg, type);
circa_output_error_val(stack, &msg);
delete server;
return;
}
uv_loop_t* loop = get_uv_loop(stack->world);
circa_set_list(&server->connections, 0);
uv_tcp_init(stack->world->libuvWorld->uv_loop, &server->uv_tcp);
struct sockaddr_in bind_addr = uv_ip4_addr(circa_string(ip), circa_int(port));
uv_tcp_bind(&server->uv_tcp, bind_addr);
int err = uv_listen((uv_stream_t*) &server->uv_tcp, 128, server_on_connect);
server->uv_tcp.data = server;
if (err) {
Value msg;
circa_set_string(&msg, "Listen error: ");
circa_string_append(&msg, uv_err_name(uv_last_error(loop)));
circa_output_error_val(stack, &msg);
return;
}
Value* out = circa_set_default_output(stack, 0);
circa_set_native_ptr(circa_index(out, 0), server, ServerRelease);
}
bool load_shaders(ResourceManager* resources, const char* baseFilename, Program* programStruct)
{
Log("Loading shader: %s", baseFilename);
check_gl_error();
// Create shader program.
GLuint program = glCreateProgram();
programStruct->program = program;
// Load vertex shader.
circa::Value vertShaderPathname;
circa_set_string(&vertShaderPathname, baseFilename);
circa_string_append(&vertShaderPathname, ".vsh");
circa::Value vertShader;
resources->loadAsText(circa_string(&vertShaderPathname), &vertShader);
if (circa_is_error(&vertShader) || !circa_is_string(&vertShader)) {
Log("Failed to load vertex shader: %v", &vertShaderPathname);
return false;
}
// Compile vertex shader
circa::Value vertShaderIndex;
compile_shader(GL_VERTEX_SHADER, &vertShader, &vertShaderIndex);
if (circa_is_error(&vertShaderIndex)) {
Log("Failed to compile vertex shader:", &vertShaderPathname);
return false;
}
// Load fragment shader
circa::Value fragShaderPathname;
circa_set_string(&fragShaderPathname, baseFilename);
circa_string_append(&fragShaderPathname, ".fsh");
circa::Value fragShader;
resources->loadAsText(circa_string(&fragShaderPathname), &fragShader);
if (circa_is_error(&fragShader) || !circa_is_string(&fragShader)) {
Log("Failed to load fragment shader:", &fragShaderPathname);
return false;
}
// Compile fragment shader
circa::Value fragShaderIndex;
compile_shader(GL_FRAGMENT_SHADER, &fragShader, &fragShaderIndex);
check_gl_error();
if (circa_is_error(&fragShaderIndex)) {
Log("Failed to compile frag shader: %v", &fragShaderPathname);
return false;
}
int vertShaderHandle = circa_int(&vertShaderIndex);
int fragShaderHandle = circa_int(&fragShaderIndex);
// Attach vertex shader to program.
glAttachShader(program, vertShaderHandle);
check_gl_error();
// Attach fragment shader to program.
glAttachShader(program, fragShaderHandle);
check_gl_error();
// Link program.
if (!link_program(program)) {
Log("Failed to link shaders: %s", baseFilename);
glDeleteShader(vertShaderHandle);
glDeleteShader(fragShaderHandle);
if (program) {
glDeleteProgram(program);
program = 0;
}
check_gl_error();
return false;
}
check_gl_error();
// Get attribute locations
programStruct->attributes.vertex = glGetAttribLocation(program, "vertex");
programStruct->attributes.tex_coord = glGetAttribLocation(program, "tex_coord");
check_gl_error();
// Get uniform locations.
programStruct->uniforms.modelViewProjectionMatrix =
glGetUniformLocation(program, "modelViewProjectionMatrix");
programStruct->uniforms.normalMatrix = glGetUniformLocation(program, "normalMatrix");
programStruct->uniforms.sampler = glGetUniformLocation(program, "sampler");
programStruct->uniforms.sampler2 = glGetUniformLocation(program, "sampler2");
programStruct->uniforms.color = glGetUniformLocation(program, "color");
programStruct->uniforms.blend = glGetUniformLocation(program, "blend");
check_gl_error();
return true;
}
