예제 #1
0
파일: eecs467_util.c 프로젝트: DH-std/A3
void
eecs467_default_display_started (vx_application_t *app, vx_display_t *disp)
{
    eecs467_default_implementation_t *impl = app->impl;

    vx_layer_t *layer = vx_layer_create (impl->world);
    vx_layer_set_background_color (layer, vx_black);
    vx_layer_set_display (layer, disp);

    pthread_mutex_lock (&impl->mutex);
    // store a reference to the world and layer that we associate with each vx_display_t
    zhash_put (impl->layers, &disp, &layer, NULL, NULL);
    pthread_mutex_unlock (&impl->mutex);

    if (impl->vxeh != NULL)
        vx_layer_add_event_handler (layer, impl->vxeh);

    vx_layer_camera_op (layer, OP_PROJ_PERSPECTIVE);
    float eye[3]    = {  0,  0,  1 };
    float lookat[3] = {  0,  0,  0 };
    float up[3]     = {  0,  1,  0 };
    vx_layer_camera_lookat (layer, eye, lookat, up, 1);

    vx_code_output_stream_t *couts = vx_code_output_stream_create (128);
    couts->write_uint32 (couts, OP_LAYER_CAMERA);
    couts->write_uint32 (couts, vx_layer_id (layer));
    couts->write_uint32 (couts, OP_INTERFACE_MODE);
    couts->write_float  (couts, 2.5f);
    disp->send_codes (disp, couts->data, couts->pos);
    vx_code_output_stream_destroy (couts);
}
예제 #2
0
vx_buffer_t * vx_world_get_buffer(vx_world_t * world, const char * name)
{
    vx_buffer_t * buffer = NULL;

    pthread_mutex_lock(&world->buffer_mutex);

    zhash_get(world->buffer_map, &name, &buffer);
    if (buffer == NULL) {
        buffer = calloc(1, sizeof(vx_buffer_t));

        buffer->name = strdup(name);
        buffer->world = world;
        buffer->draw_order = 0;

        buffer->back_objs = zarray_create(sizeof(vx_object_t*));
        buffer->pending_objs = zarray_create(sizeof(vx_object_t*));
        buffer->front_objs = zarray_create(sizeof(vx_object_t*));

        buffer->front_resc = zhash_create(sizeof(uint64_t), sizeof(vx_resc_t*), zhash_uint64_hash, zhash_uint64_equals);
        buffer->front_codes = vx_code_output_stream_create(128);

        pthread_mutex_init(&buffer->mutex, NULL);

        vx_buffer_t * oldBuffer= NULL;
        zhash_put(buffer->world->buffer_map, &buffer->name, &buffer, NULL, &oldBuffer);
        assert(oldBuffer == NULL);
    }

    pthread_mutex_unlock(&world->buffer_mutex);

    return buffer;
}
예제 #3
0
void buffer_checkbox_changed(GtkWidget * widget, gpointer userdata)
{
    buffer_info_t * buffer = userdata;

    int enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

    vx_code_output_stream_t * outs = vx_code_output_stream_create(128);
    outs->write_uint32 (outs, OP_BUFFER_ENABLED);
    outs->write_uint32 (outs, buffer->layer_id);
    outs->write_str (outs, buffer->name);
    outs->write_uint8 (outs, enabled? 1 : 0); // convert to byte

    buffer->man->disp->send_codes(buffer->man->disp, outs->data, outs->pos);

    vx_code_output_stream_destroy(outs);
}
예제 #4
0
static vx_code_output_stream_t * make_buffer_resource_codes(vx_buffer_t * buffer, zhash_t * resources)
{
    vx_code_output_stream_t * couts = vx_code_output_stream_create(256);
    couts->write_uint32(couts, OP_BUFFER_RESOURCES); // tell the display which resources are currently in use
    couts->write_uint32(couts, buffer->world->worldID);
    couts->write_str(couts, buffer->name);
    couts->write_uint32(couts, zhash_size(resources));

    zhash_iterator_t itr;
    zhash_iterator_init(resources, &itr);

    uint64_t guid = -1;
    vx_resc_t *resc = NULL;
    while (zhash_iterator_next(&itr, &guid, &resc))
        couts->write_uint64(couts, guid);
    return couts;
}
예제 #5
0
// Pass in a codes describing which resources are no longer in use. Decrement user counts,
// and return a list of all resources whos counts have reached zero, which therefore
// should be deleted from the display using a OP_DEALLOC_RESOURCES opcode
void vx_resc_manager_buffer_resources(vx_resc_manager_t * mgr, const uint8_t * data, int datalen)
{
    if (0) print_manager(mgr);

    vx_code_input_stream_t * cins = vx_code_input_stream_create(data, datalen);
    int code = cins->read_uint32(cins);
    assert(code == OP_BUFFER_RESOURCES);
    int worldID = cins->read_uint32(cins);
    char * name = strdup(cins->read_str(cins)); //freed when cur_resources is eventually removed from the buffer map
    int count = cins->read_uint32(cins);

    zhash_t * cur_resources = zhash_create(sizeof(uint64_t), sizeof(vx_resc_t*), zhash_uint64_hash, zhash_uint64_equals);
    vx_resc_t * vr = NULL;
    for (int i = 0; i < count; i++) {
        uint64_t id = cins->read_uint64(cins);
        zhash_put(cur_resources, &id, &vr, NULL, NULL);
    }
    assert(cins->pos == cins->len); // we've emptied the stream
    vx_code_input_stream_destroy(cins);

    // 1 Update our records
    zhash_t * worldBuffers = NULL;
    zhash_get(mgr->allLiveSets, &worldID, &worldBuffers);
    if (worldBuffers == NULL) {
        worldBuffers = zhash_create(sizeof(char*), sizeof(zhash_t*), zhash_str_hash, zhash_str_equals);
        zhash_put(mgr->allLiveSets, &worldID, &worldBuffers, NULL, NULL);
    }

    zhash_t * old_resources = NULL;
    char * old_name = NULL;
    zhash_put(worldBuffers, &name, &cur_resources, &old_name, &old_resources);
    free(old_name);

    // 2 Figure out which resources have become unused:
    if(old_resources != NULL) {
        removeAll(old_resources, cur_resources);

        zarray_t * dealloc = zarray_create(sizeof(uint64_t));

        // now 'old_resources' contains only the resources that are no longer referenced
        // iterate through each one, and see if there is a buffer somewhere that references it
        zhash_iterator_t prev_itr;
        zhash_iterator_init(old_resources, &prev_itr);
        uint64_t id = -1;
        vx_resc_t * vr = NULL;
        while(zhash_iterator_next(&prev_itr, &id, &vr)) {
            // Check all worlds
            zhash_iterator_t  world_itr;// gives us all worlds
            zhash_iterator_init(mgr->allLiveSets, &world_itr);
            uint32_t wIDl = -1;
            zhash_t * buffer_map = NULL;
            while(zhash_iterator_next(&world_itr, &wIDl, &buffer_map)) {
                zhash_iterator_t buffer_itr; // gives us all buffers
                zhash_iterator_init(buffer_map, &buffer_itr);
                char * bName = NULL;
                zhash_t * resc_map = NULL;
                while(zhash_iterator_next(&buffer_itr, &bName, &resc_map)) {
                    if (zhash_contains(resc_map, &id)) {
                        goto continue_outer_loop;
                    }
                }

            }

            // If none of the worlds have this resource, we need to flag removal
            zarray_add(dealloc, &id);

          continue_outer_loop:
            ;
        }


        // 3 Issue dealloc commands
        if (zarray_size(dealloc) > 0) {
            vx_code_output_stream_t * couts = vx_code_output_stream_create(512);
            couts->write_uint32(couts, OP_DEALLOC_RESOURCES);
            couts->write_uint32(couts, zarray_size(dealloc));
            for (int i = 0; i < zarray_size(dealloc); i++) {
                uint64_t id = 0;
                zarray_get(dealloc, i, &id);
                couts->write_uint64(couts, id);
            }

            mgr->disp->send_codes(mgr->disp, couts->data, couts->pos);

            vx_code_output_stream_destroy(couts);

            // Also remove the resources we deallocated from remoteResc
            for (int i = 0; i < zarray_size(dealloc); i++) {
                uint64_t id = 0;
                zarray_get(dealloc, i, &id);

                assert(zhash_contains(mgr->remoteResc, &id));
                zhash_remove(mgr->remoteResc, &id, NULL, NULL);
            }

        }
        zarray_destroy(dealloc);
        zhash_destroy(old_resources);

    }
    if (0) {
        print_manager(mgr);
        printf("\n\n");
    }
}
예제 #6
0
static void menu_action(GtkWidget * menuitem, char * shortname, gpointer userdata)
{
    state_t * state = userdata;
    if (state->popup_layer_id == 0)
        return;

    vx_code_output_stream_t * couts = vx_code_output_stream_create(128);


    if (verbose) printf("DBG menu: Label %s shortname %s\n",
                        gtk_menu_item_get_label(GTK_MENU_ITEM(menuitem)), shortname);

    if (!strcmp(shortname,"reset_camera")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_DEFAULTS);
    } else if (!strcmp(shortname,"ortho")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_PROJ_ORTHO);
    } else if (!strcmp(shortname,"perspective")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_PROJ_PERSPECTIVE);
    } else if (!strcmp(shortname,"iface2.0D")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_INTERFACE_MODE);
        couts->write_float(couts, 2.0f);
    } else if (!strcmp(shortname,"iface2.5D")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_INTERFACE_MODE);
        couts->write_float(couts, 2.5f);
    } else if (!strcmp(shortname,"iface3.0D")) {
        couts->write_uint32(couts, OP_LAYER_CAMERA);
        couts->write_uint32(couts, state->popup_layer_id);
        couts->write_uint32(couts, OP_INTERFACE_MODE);
        couts->write_float(couts, 3.0f);
    } else if (!strcmp(shortname,"buffer_manager")) {
        vx_gtk_buffer_manager_show(state->buffer_manager, 1);
    } else if (!strcmp(shortname,"scene")) {
        couts->write_uint32(couts, OP_WINDOW_SCENE);
        // optional, filled in automatically couts->write_str(couts, "test.vxs");
    } else if (!strcmp(shortname,"screen_shot")) {
        couts->write_uint32(couts, OP_WINDOW_SCREENSHOT);
        // optional, filled in automatically couts->write_str(couts, "test.png");
    } else if (!strcmp(shortname,"record_movie")) {
        couts->write_uint32(couts, OP_WINDOW_MOVIE_RECORD);
        // optional, filled in automatically couts->write_str(couts, "test.ppms.gz");
    } else if (!strcmp(shortname,"stop_movie")) {
        couts->write_uint32(couts, OP_WINDOW_MOVIE_STOP);
    }


    if (couts->pos != 0) {
        state->super->send_codes(state->super, couts->data, couts->pos);
    }

        /* pthread_mutex_lock(&state->mutex); */

        /* pthread_mutex_unlock(&state->mutex); */

    vx_code_output_stream_destroy(couts);
}
예제 #7
0
static void display_started(vx_application_t * app, vx_display_t * disp)
{
    state_t * state = app->impl;

    {
        vx_layer_t * layer = vx_layer_create(state->world);
        vx_layer_set_display(layer, disp);
        //vx_layer_camera_op(layer, OP_PROJ_ORTHO);

        if (1) {
            float view_rel[] = {0.0, 0.0, 1.0, 1.0};
            vx_layer_set_viewport_rel(layer, view_rel);
        }

        if (1) {
            float eye3[] = {CAM_RADIUS,0,45.0f};
            float lookat3[] = {CAM_RADIUS,0,0.0f};
            float up3[] = {0,1,0};
            vx_layer_camera_lookat(layer, eye3, lookat3, up3, 0);
        }

        if (1) {
            float xy0[] = {-10,-10};
            float xy1[] = {10,10};
            vx_layer_camera_fit2D(layer, xy0, xy1, 0);
        }


        pthread_mutex_lock(&state->mutex);
        // store a reference to the world and layer that we associate with each vx_display_t
        zhash_put(state->layers, &disp, &layer, NULL, NULL);
        pthread_mutex_unlock(&state->mutex);

        // must redraw after each new display connects

        draw(state, state->world);
    }

    {
        vx_layer_t * layer = vx_layer_create(state->world2);
        vx_layer_set_display(layer, disp);
        vx_layer_camera_op(layer, OP_PROJ_ORTHO);

        {
            vx_layer_set_viewport_abs(layer, OP_ANCHOR_TOP_RIGHT, 100, 100);
        }

        {
            float eye3[] = {10.0f,10.0f,100.0f};
            float lookat3[] = {10.0f,10.0f,0.0f};
            float up3[] = {0,1,0};
            vx_layer_camera_lookat(layer, eye3, lookat3, up3, 0);
        }

        {
            float xy0[] = {-10,-10};
            float xy1[] = {10,10};
            vx_layer_camera_fit2D(layer, xy0, xy1, 0);
        }

        vx_layer_add_event_handler(layer, &state->veh);
        vx_layer_add_camera_listener(layer, &state->cl);


        /*
        pthread_mutex_lock(&state->mutex);
        // store a reference to the world and layer that we associate with each vx_display_t
        zhash_put(state->layers, &disp, &layer, NULL, NULL);
        pthread_mutex_unlock(&state->mutex);
        */

        // must redraw after each new display connects

        draw(state, state->world2);
    }


    if (0) {
        vx_layer_t * layer = vx_layer_create(state->world3);
        vx_layer_set_display(layer, disp);
        vx_layer_set_background_color(layer, vx_green);

        // Manually send the codes for animating a layer (not in
        // vx_layer_api yet):

        {
            float viewport[] = {0, 0.5, 0.5, 0.5};

            vx_code_output_stream_t * couts = vx_code_output_stream_create(128);
            couts->write_uint32(couts, OP_LAYER_VIEWPORT_REL);
            couts->write_uint32(couts, vx_layer_id(layer));
            for (int i = 0; i < 4; i++)
                couts->write_float(couts, viewport[i]);
            couts->write_uint32(couts, 2000); // animate over 2 seconds

            disp->send_codes(disp, couts->data, couts->pos);

            vx_code_output_stream_destroy(couts);
        }

        draw(state, state->world3); // XXX Why is this required to get
        // the layer to show up?
    }


}