void frame_free(int frame)
{
KASSERT(frame >= 0 && frame < num_frames);
lock_acquire(coremap_lock);
int pid = coremap_ptr[frame].pid;
int id = coremap_ptr[frame].id;
if (pid != 0) {
KASSERT(curproc->pid == pid);
set_frame(frame, UNALLOCATED, 0,0);
ZERO_OUT_FRAME(frame);
goto FRAME_FREE_DONE;
}
for (int i = 0; i < num_frames; i++){
if (coremap_ptr[i].pid != 0 || coremap_ptr[i].id != id) continue;
set_frame(i, UNALLOCATED, 0,0);
ZERO_OUT_FRAME(i);
if (id_not_used != NULL){ // recycle id's for kernel memory
q_addtail(id_not_used, (void*)id);
}
goto FRAME_FREE_DONE;
}
panic("Invalid freeing of the frame for the unique pair (pid,id)=(%d,%d)\n", pid, id);
FRAME_FREE_DONE:
lock_release(coremap_lock);
}
void gun::Sprite::Update(double dt)
{
if(animations_.size() > 0)
{
Animation animation = current_anim();
if (is_playing_)
{
if (frame_ >= animation.num_frames())
{
if (is_looping_)
{
set_frame(0);
}
else
{
set_frame(animation.num_frames() - 1);
is_playing_ = false;
}
}
set_frame(frame_ + dt * anim_speed_);
}
}
}
int
uframe_alloc1(int *frame, pid_t pid, int id)
{
int ret = 1;
lock_acquire(coremap_lock);
if(coremap_has_space() == 0)
{
ret = core_kickvictim(frame);
if(ret) goto UFRAME_ALLOC1_FINISH;
set_frame(*frame, USER, pid, id);
ZERO_OUT_FRAME(*frame);
goto UFRAME_ALLOC1_FINISH;
}
// start search from the MIDDLE of the coremap
int idx = num_frames >> 1;
for(int i = 0; i < num_frames; i++) {
if(coremap_ptr[idx].status == UNALLOCATED) {
set_frame(idx, USER, pid, id);
*frame = idx;
ret = 0;
ZERO_OUT_FRAME(*frame);
break;
}
idx = (idx + 1) % num_frames;
}
UFRAME_ALLOC1_FINISH:
lock_release(coremap_lock);
DEBUG(DB_VM,"Finished uframe_alloc1 retval:%d\n", ret);
return ret;
}
g1_movie_flow_class::advance_status g1_movie_flow_class::advance_movie_with_time()
{
poll_scores();
advance_status stat=PLAYING;
if (t_cut_scenes)
{
i4_time_class now;
sw32 md;
do
{
md=now.milli_diff(frame_time);
if (md>(1000/G1_MOVIE_HZ))
{
frame_time.add_milli((1000/G1_MOVIE_HZ));
if (frame+1<current()->total_frames())
{
set_frame(frame+1);
}
else if (scene+1<t_cut_scenes)
{
do
{
set_scene(scene+1);
start();
set_frame(0);
stat=NEXT_SCENE;
if (scene+1==t_cut_scenes && current()->total_frames()==0)
{
stop();
return DONE;
}
}
while (current()->total_frames()==0);
}
else
{
stop();
return DONE;
}
}
}
while (md>(1000/G1_MOVIE_HZ));
}
return stat;
}
static void do_action(struct Player *pp, Action ac)
{
Action pre_action;
pre_action = previous_action(pp);
int pre_frame = pre_action.frame;
int nframe;
if (equal_action(pre_action, ac))
{
nframe = next_frame(pp, ac, pre_frame);
set_frame(pp, nframe);
complete_action(pp);
}
else if (pre_frame != 0) // previous action unfinished
{
if (action_interruptable(pre_action))
{
set_action(pp, ac);
complete_action(pp); //pp->spd = spd;
}
else
do_action(pp, pre_action);
}
else // previous action finished, set new action
{
set_action(pp, ac);
complete_action(pp);
}
}
gun::Sprite::Sprite(const sf::Texture& texture,
const std::map<int, Animation>& animations, int anim_index, double anim_speed)
: sprite_(sf::Sprite(texture)), draw_order_(0), is_visible_(true), is_playing_(false),
is_looping_(false), animations_(animations), anim_speed_(anim_speed), anim_index_(anim_index)
{
set_frame(0);
}
/**
* Creates a new thread structure. If @process is not NULL, the thread is added
* to the linked list of threads for the given process.
*/
scheduler_tcb_t *scheduler_new_tcb(scheduler_pcb_t *process) {
unsigned int frame = find_free_frame();
set_frame(frame);
frame *= 0x1000;
frame += TCB_START;
// allocate the memory for this structure
uintptr_t phys = vm_allocate_phys();
platform_pm_map(platform_pm_get_kernel_table(), frame, phys, VM_FLAGS_KERNEL);
// allocate a thread struct
scheduler_tcb_t *tcb = (scheduler_tcb_t *) frame;
tcb->thread_id = scheduler_new_tid();
// add it to the linked list of threads
if(process) {
scheduler_tcb_t *thread = process->thread;
while(thread) {
// next thread NULL?
if(!thread->next) {
thread->next = tcb;
break;
}
// check the next thread
thread = thread->next;
}
}
return tcb;
}
/**
* Creates a new process structure. This will have one thread created for it,
* but with no information populated.
*/
scheduler_pcb_t *scheduler_new_process(void) {
unsigned int frame = find_free_frame();
set_frame(frame);
frame *= 0x1000;
frame += TCB_START;
// allocate the memory for this structure
uintptr_t phys = vm_allocate_phys();
platform_pm_map(platform_pm_get_kernel_table(), frame, phys, VM_FLAGS_KERNEL);
// allocate the process struct here
scheduler_pcb_t *pcb = (scheduler_pcb_t *) frame;
pcb->process_id = scheduler_new_pid();
// allocate a TCB
scheduler_tcb_t *tcb = scheduler_new_tcb(pcb);
// initialise process struct
pcb->thread = tcb;
// initialise thread struct
return pcb;
}
void SubApplication::update(float dt)
{
if (done)
return;
starting = false;
Frame * old_frame = global_manager->frame;
global_manager->frame = &subapp_frame;
if (subapp_frame.next_frame != -1) {
int next_frame = subapp_frame.next_frame;
if (subapp_frame.index != -1)
subapp_frame.on_end();
global_manager->frame = old_frame;
set_frame(next_frame);
return;
}
bool ret = subapp_frame.update(dt);
if (!ret)
subapp_frame.on_end();
global_manager->frame = old_frame;
if (ret)
return;
done = true;
set_visible(false);
}
void AnimatedSprite::_res_changed() {
set_frame(frame);
_change_notify("frame");
_change_notify("animation");
update();
}
void page_alloc(struct page *p, int flags)
{
uint32_t idx;
ASSERT(p != NULL);
if (p->frame != 0) {
DEBUG(DL_WRN, ("page(%p), frame(%x), flags(%d)\n",
p, p->frame, flags));
PANIC("alloc page in use");
} else {
spinlock_acquire(&_pages_lock);
/* Get the first free frame from our global frame set */
idx = first_frame();
if (idx == (uint32_t)(-1)) {
PANIC("No free frames!\n");
}
/* Mark the frame address as being used */
set_frame(idx * PAGE_SIZE);
spinlock_release(&_pages_lock);
p->present = 1;
p->frame = idx;
}
#ifdef _DEBUG_MM
DEBUG(DL_DBG, ("page(%p), frame(%x).\n", p, p->frame));
#endif /* _DEBUG_MM */
}
static address_t pdir_set(size_t pfno)
{
pde_t *pdir_boot;
uint16_t pdir_idx;
/* map the page number and set as allocated */
/* for SUPERVISOR */
set_frame(pfno, PAGE_SUPERV);
pdir_boot = (pde_t *) (pfno << PAGE_SHIFT);
/* pdir_boot = pdir; */
pdir = pdir_boot;
/* 1st 4MiB identically mapped */
/* needs to be invalidated later */
/* ptable_boot with no shift because is already aligned to a page boundary */
*(pdir_boot++) = (address_t) ptable_boot | PDE_P | PDE_RW;
for (pdir_idx = 1; pdir_idx < __phys_to_pfn(_start); pdir_idx++)
*(pdir_boot++) = ~PDE_P;
/* pdir[768] mapped to the first 4MiB of phys RAM */
*(pdir_boot++) = (address_t) ptable_boot | PDE_P | PDE_RW;
for (; pdir_idx < 1023; pdir_idx++)
*(pdir_boot++) = ~PDE_P;
*(pdir_boot++) = (address_t) pdir | PDE_P | PDE_RW;
return (address_t) pdir_boot;
}
void Screen::init_control (Control* par) {
set_background (C_SCREEN_BACKGROUND);
set_foreground (C_FOREGROUND);
set_font_color (C_FOREGROUND);
set_frame (0);
reinitialize ();
}
void initialize_paging(uint32_t memsize)
{
nframes = memsize / 4;
frames = (uint32_t *)kmalloc(INDEX_FROM_BIT(nframes));
uintptr_t pg;
assert(frames != NULL);
memset(frames, 0, INDEX_FROM_BIT(nframes));
uintptr_t physical;
kernel_directory = (page_directory_t *)kmalloc_ap(sizeof(page_directory_t), &physical);
memset(kernel_directory, 0, sizeof(page_directory_t));
current_directory = kernel_directory;
#if 1
get_page(0,1,kernel_directory)->present = 0;
set_frame(0);
for(uintptr_t i = 0x1000; i < placement_address+0x3000; i += 0x1000)
#else
for(uintptr_t i = 0x0; i < placement_address+0x3000; i += 0x1000)
#endif
{
direct_frame( get_page(i, 1, kernel_directory), 1, 0, i);
}
kernel_directory->physical_addr = (uintptr_t)kernel_directory->tables_physical;
uintptr_t heap_start = KERNEL_HEAP_START;
if(heap_start <= placement_address + 0x3000)
{
heap_start = placement_address + 0x100000;
}
for (uintptr_t i = placement_address + 0x3000; i < heap_start; i += 0x1000)
{
alloc_frame(get_page(i, 1, kernel_directory), 1, 0);
}
for(uintptr_t i = heap_start; i < heap_start + KERNEL_HEAP_INIT; i += 0x1000)
{
get_page(i, 1, kernel_directory);
}
for(uintptr_t i = heap_start; i < heap_start + KERNEL_HEAP_INIT; i += 0x1000)
{
alloc_frame(get_page(i, 1, kernel_directory), 0, 0);
}
register_isr_handler(13, general_protection_fault);
register_isr_handler(14, page_fault);
switch_page_directory(kernel_directory);
kernel_heap = create_heap(heap_start, heap_start + KERNEL_HEAP_INIT, KERNEL_HEAP_END, 0, 0);
//kernel_heap = create_heap(heap_start, KERNEL_HEAP_END, KERNEL_HEAP_END, 0, 0);
}
/**
* \brief Creates a single-frame tile pattern.
* \param frame Coordinates of the single frame to make.
*/
TilePatternData::TilePatternData(const Rectangle& frame) :
ground(Ground::TRAVERSABLE),
default_layer(0),
scrolling(TileScrolling::NONE),
frames() {
set_frame(frame);
}
Sprite::Sprite(Controller* c, Frame f): Entity(c) {
curframe=0;
_counter=1;
animspeed=1;
_left=_top=_right=_bottom=0;
set_frame(f);
}
gun::Sprite::Sprite(const sf::Texture& texture,
const Animation& animation, double anim_speed)
: sprite_(sf::Sprite(texture)), draw_order_(0), is_visible_(true), is_playing_(false),
is_looping_(false), anim_speed_(anim_speed), anim_index_(0)
{
animations_.insert(std::pair<int, Animation>(anim_index_, animation));
set_frame(0);
}
void direct_frame(page_entry_t * page, int32_t is_kernel, int32_t is_writeable, uintptr_t addr)
{
page->present = 1;
page->rw = (is_writeable) ? 1 : 0;
page->user = (is_kernel) ? 0 : 1;
page->frame = addr / 0x1000;
set_frame(addr);
}
u32int alloc_frame()
{
u32int idx = first_frame();
if(idx == 0xffffffff){
//full先这么着，换页的事儿后面再写
PANIC("full");
}
u32int ret = idx * 0x1000;
set_frame(ret);
return ret;
}
void AnimatedSprite::set_animation(const StringName &p_animation) {
if (animation == p_animation)
return;
animation = p_animation;
_reset_timeout();
set_frame(0);
_change_notify();
update();
}
void PicPreConfig::mousePressEvent( QMouseEvent *event ) {
if ( event->button() == Qt::LeftButton ) {
qDebug()<<"global"<<m_pt_press_global<<m_pt_press_global.x()<<m_pt_press_global.y()<<"event"<<event->x()<<event->y();
if( event->x()>this->x() && event->x()<= this->x()+this->width() && event->y()>this->y() && event->y()<=this->y()+this->height() ) {
set_frame( event );
}
}
qDebug()<<"PicPreConfig::mousePressEvent( QMouseEvent *event )"<<"点击";
}
int core_sweep(pid_t pid){
KASSERT(pid != 0); // NEVER sweep kernel internal memory
int count = 0;
for (int i = 0; i < num_frames; i++){
if (coremap_ptr[i].pid != pid) continue;
set_frame(i, UNALLOCATED, 0,0);
ZERO_OUT_FRAME(i);
count++;
}
return count;
}
ENV_type Environment_Extend_C(NIL_type)
{ ENV_type extended_environment;
FRM_type frame;
UNS_type scope,
size;
VEC_type extended_environment_vector;
size = size_environment(Current_environment);
size += 1;
extended_environment_vector = Cache_Make_Vector_C(size);
extended_environment = (ENV_type)extended_environment_vector;
for (scope = 1;
scope < size;
scope += 1)
{ frame = get_frame(Current_environment,
scope);
set_frame(extended_environment,
scope,
frame); }
apply_MRK(Current_frame);
set_frame(extended_environment,
size,
Current_frame);
return extended_environment; }
void xform_node_t::do_calc_hash_str( const render::context_t& context)
{
motion_blur_info_t::loop_data_t d( motion_blur_loop_data( context.frame, context.motion_blur_extra_samples,
context.motion_blur_shutter_factor));
hash_generator() << ( int) get_filter_type();
if( d.num_samples == 1)
param_set().add_to_hash( hash_generator());
else
{
float t = d.start_time;
for( int i = 0; i < d.num_samples; ++i)
{
set_frame( t);
param_set().add_to_hash( hash_generator());
t += d.time_step;
}
set_frame( context.frame);
}
}
rstbx::detector_model::sensor::sensor(
const scitbx::vec3<double>& _origin,
const scitbx::vec3<double>& _dir1,
const scitbx::vec3<double>& _dir2,
const scitbx::vec2<double>& _lim1,
const scitbx::vec2<double>& _lim2):
lim1(_lim1),
lim2(_lim2),
normal(),
d(),
D(),
d_is_invertible(false)
{
set_frame(_origin, _dir1, _dir2);
}
void alloc_frame(struct page *page, int kernel, int writable)
{
uint32_t idx;
if (page->frame) return;
else
{
idx = first_frame();
if (idx == (uint32_t)-1)
PANIC("No free frames!");
set_frame(idx*PAGE_SIZ);
page->present = 1;
page->rw = writable;
page->user = kernel;
page->frame = idx;
}
}
void AnimatedSprite::set_sprite_frames(const Ref<SpriteFrames> &p_frames) {
if (frames.is_valid())
frames->disconnect("changed",this,"_res_changed");
frames=p_frames;
if (frames.is_valid())
frames->connect("changed",this,"_res_changed");
if (!frames.is_valid()) {
frame=0;
} else {
set_frame(frame);
}
update();
}
GameManager() : scene(NULL)
{
#ifdef DEBUG
glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 0);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
glfwOpenWindow(WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0, 0, 0, 0, 0,
GLFW_WINDOW);
glfwSetWindowTitle(NAME);
glfwSwapInterval(0);
// OpenGL settings
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
set_frame(0);
}
void gun::Sprite::PlayAnimation(int anim_index, bool is_looping)
{
int old_anim_index = anim_index_;
// If not playing an animation or playing a different animation...
if (!is_playing_ || anim_index != anim_index_)
{
// Set playing to true, set if it should loop, and set the animation.
is_playing_ = true;
is_looping_ = is_looping;
anim_index_ = anim_index;
}
if (anim_index != old_anim_index)
{
set_frame(0);
}
}
void init_pmm(u32int start, u32int end)
{
//32MB最多(25) 那就是8k个页(13 + 12) 256个u32int(8 + 5 + 12)
//一个页面足够存了
pmm_location = align(start);
frames = (u32int*)pmm_location;
memset(frames, 0, 0x1000);
pmm_location += 0x1000;
u32int iter;
for(iter = 0; iter < pmm_location; iter += 0x100){
set_frame(iter);
nframes++;
}
for(iter = pmm_location; iter < end; iter += 0x100){
free_frame(iter);
nframes++;
}
}
