gameswf_impl.cpp

一个开源的嵌入式flash播放器 具体看文档和例子就可

			*x = m_mouse_x;
			*y = m_mouse_y;
			*buttons = m_mouse_buttons;
		}

		movie*	get_root_movie() { return m_movie.get_ptr(); }


		void	stop_drag()
		{
			m_drag_state.m_character = NULL;
		}


		movie_definition*	get_movie_definition() { return m_movie->get_movie_definition(); }

		uint32	get_file_bytes() const
		{
			return m_def->get_file_bytes();
		}

		virtual int    add_interval_timer(void *timer)
		{
			Timer *ptr = static_cast<Timer *>(timer);
			
			m_interval_timers.push_back(ptr);
			return m_interval_timers.size();
		}
	
		virtual void    clear_interval_timer(int x)
		{
			m_interval_timers.remove(x-1);
			//m_interval_timers[x]->clearInterval();
		}
	
		virtual void    do_something(void *timer)
		{
			log_msg("FIXME: %s: unimplemented\n", __FUNCTION__);
		}
		
		// 0-based!!
		int	get_current_frame() const { return m_movie->get_current_frame(); }
		float	get_frame_rate() const { return m_def->get_frame_rate(); }

		virtual float	get_pixel_scale() const
		// Return the size of a logical movie pixel as
		// displayed on-screen, with the current device
		// coordinates.
		{
			return m_pixel_scale;
		}

		// @@ Is this one necessary?
		character*	get_character(int character_id)
		{
			return m_movie->get_character(character_id);
		}

		void	set_background_color(const rgba& color)
		{
			m_background_color = color;
		}

		void	set_background_alpha(float alpha)
		{
			m_background_color.m_a = iclamp(frnd(alpha * 255.0f), 0, 255);
		}

		float	get_background_alpha() const
		{
			return m_background_color.m_a / 255.0f;
		}

		float	get_timer() const { return m_timer; }

		void	restart() { m_movie->restart(); }
		
		void	advance(float delta_time)
		{
			int i;
			if (m_on_event_load_called == false)
			{
				// Must do loading events.  For child sprites this is
				// done by the dlist, but root movies don't get added
				// to a dlist, so we do it here.
				m_on_event_load_called = true;
				m_movie->on_event_load();
			}
#if 0
			// Must check the socket connection for data
			if (m_on_event_xmlsocket_ondata_called == true) {
				m_movie->on_event_xmlsocket_ondata();
			}
			
			if (m_on_event_xmlsocket_onxml_called == true) {
				m_movie->on_event_xmlsocket_onxml();
			}


			// Must check the progress of the MovieClip being loaded
			if (m_on_event_load_progress_called == true) {
				m_movie->on_event_load_progress();				
			}
#endif
			if (m_interval_timers.size() > 0) {
				for (i=0; i<m_interval_timers.size(); i++) {
					if (m_interval_timers[i]->expired()) {
						// printf("FIXME: Interval Timer Expired!\n");
						//m_movie->on_event_interval_timer();
						m_movie->do_something(m_interval_timers[i]);
						// clear_interval_timer(m_interval_timers[i]->getIntervalID()); // FIXME: we shouldn't really disable the timer here
					}
				}
			}
			
			
			m_timer += delta_time;
			// @@ TODO handle multi-frame catch-up stuff
			// here, and make it optional.  Make
			// movie::advance() a fixed framerate w/ no
			// dt.

			// Handle the mouse.
			m_mouse_button_state.m_topmost_entity =
				m_movie->get_topmost_mouse_entity(PIXELS_TO_TWIPS(m_mouse_x), PIXELS_TO_TWIPS(m_mouse_y));
			m_mouse_button_state.m_mouse_button_state_current = (m_mouse_buttons & 1);
			generate_mouse_button_events(&m_mouse_button_state);

			m_movie->advance(delta_time);
		}

		// 0-based!!
		void	goto_frame(int target_frame_number) { m_movie->goto_frame(target_frame_number); }

		virtual bool	has_looped() const { return m_movie->has_looped(); }

		void	display()
		{
			if (m_movie->get_visible() == false)
			{
				// Don't display.
				return;
			}

			gameswf::render::begin_display(
				m_background_color,
				m_viewport_x0, m_viewport_y0,
				m_viewport_width, m_viewport_height,
				m_def->m_frame_size.m_x_min, m_def->m_frame_size.m_x_max,
				m_def->m_frame_size.m_y_min, m_def->m_frame_size.m_y_max);

			m_movie->display();

			gameswf::render::end_display();
		}

		virtual bool	goto_labeled_frame(const char* label)
		{
			int	target_frame = -1;
			if (m_def->get_labeled_frame(label, &target_frame))
			{
				goto_frame(target_frame);
				return true;
			}
			else
			{
				IF_VERBOSE_ACTION(
					log_error("error: movie_impl::goto_labeled_frame('%s') unknown label\n", label));
				return false;
			}
		}

		virtual void	set_play_state(play_state s) { m_movie->set_play_state(s); }
		virtual play_state	get_play_state() const { return m_movie->get_play_state(); }

		/* movie_root */
		virtual void	set_variable(const char* path_to_var, const char* new_value)
		{
			m_movie->set_variable(path_to_var, new_value);
		}

		/* movie_root */
		virtual void	set_variable(const char* path_to_var, const wchar_t* new_value)
		{
			m_movie->set_variable(path_to_var, new_value);
		}

		virtual const char*	get_variable(const char* path_to_var) const
		{
			return m_movie->get_variable(path_to_var);
		}

		/*movie_root*/
		// For ActionScript interfacing convenience.
		virtual const char*	call_method(const char* method_name, const char* method_arg_fmt, ...)
		{
			assert(m_movie != NULL);

			va_list	args;
			va_start(args, method_arg_fmt);
			const char*	result = m_movie->call_method_args(method_name, method_arg_fmt, args);
			va_end(args);

			return result;
		}

		/*movie_root*/
		virtual const char*	call_method_args(const char* method_name, const char* method_arg_fmt, va_list args)
		{
			assert(m_movie != NULL);
			return m_movie->call_method_args(method_name, method_arg_fmt, args);
		}

		virtual void	set_visible(bool visible) { m_movie->set_visible(visible); }
		virtual bool	get_visible() const { return m_movie->get_visible(); }

		virtual void * get_userdata() { return m_userdata; }
		virtual void set_userdata(void * ud ) { m_userdata = ud;  }

		virtual void	attach_display_callback(const char* path_to_object, void (*callback)(void* user_ptr), void* user_ptr)
		{
			m_movie->attach_display_callback(path_to_object, callback, user_ptr);
		}
	};


	static void	ensure_loaders_registered()
	{
		static bool	s_registered = false;
	
		if (s_registered == false)
		{
			// Register the standard loaders.
			s_registered = true;
			register_tag_loader(0, end_loader);
			register_tag_loader(2, define_shape_loader);
			register_tag_loader(4, place_object_2_loader);
			register_tag_loader(5, remove_object_2_loader);
			register_tag_loader(6, define_bits_jpeg_loader);
			register_tag_loader(7, button_character_loader);
			register_tag_loader(8, jpeg_tables_loader);
			register_tag_loader(9, set_background_color_loader);
			register_tag_loader(10, define_font_loader);
			register_tag_loader(11, define_text_loader);
			register_tag_loader(12, do_action_loader);
			register_tag_loader(13, define_font_info_loader);
			register_tag_loader(14, define_sound_loader);
			register_tag_loader(15, start_sound_loader);
			register_tag_loader(17, button_sound_loader);
			register_tag_loader(20, define_bits_lossless_2_loader);
			register_tag_loader(21, define_bits_jpeg2_loader);
			register_tag_loader(22, define_shape_loader);
			register_tag_loader(24, null_loader);	// "protect" tag; we're not an authoring tool so we don't care.
			register_tag_loader(26, place_object_2_loader);
			register_tag_loader(28, remove_object_2_loader);
			register_tag_loader(32, define_shape_loader);
			register_tag_loader(33, define_text_loader);
			register_tag_loader(37, define_edit_text_loader);
			register_tag_loader(34, button_character_loader);
			register_tag_loader(35, define_bits_jpeg3_loader);
			register_tag_loader(36, define_bits_lossless_2_loader);
			register_tag_loader(39, sprite_loader);
			register_tag_loader(43, frame_label_loader);
			register_tag_loader(46, define_shape_morph_loader);
			register_tag_loader(48, define_font_loader);
			register_tag_loader(56, export_loader);
			register_tag_loader(57, import_loader);
			register_tag_loader(59, do_init_action_loader);   
		}
	}



	void	get_movie_info(
		const char* filename,
		int* version,
		int* width,
		int* height,
		float* frames_per_second,
		int* frame_count,
		int* tag_count
		)
	// Attempt to read the header of the given .swf movie file.
	// Put extracted info in the given vars.
	// Sets *version to 0 if info can't be extracted.
	{
		if (s_opener_function == NULL)
		{
			log_error("error: get_movie_info(): no file opener function registered\n");
			if (version) *version = 0;
			return;
		}

		tu_file*	in = s_opener_function(filename);
		if (in == NULL || in->get_error() != TU_FILE_NO_ERROR)
		{
			log_error("error: get_movie_info(): can't open '%s'\n", filename);
			if (version) *version = 0;
			delete in;
			return;
		}

		Uint32	file_start_pos = in->get_position();
		Uint32	header = in->read_le32();
		Uint32	file_length = in->read_le32();
		Uint32	file_end_pos = file_start_pos + file_length;

		int	local_version = (header >> 24) & 255;
		if ((header & 0x0FFFFFF) != 0x00535746
		    && (header & 0x0FFFFFF) != 0x00535743)
		{
			// ERROR
			log_error("error: get_movie_info(): file '%s' does not start with a SWF header!\n", filename);
			if (version) *version = 0;
			delete in;
			return;
		}
		bool	compressed = (header & 255) == 'C';

		tu_file*	original_in = NULL;
		if (compressed)
		{
#if TU_CONFIG_LINK_TO_ZLIB == 0
			log_error("get_movie_info(): can't read zipped SWF data; TU_CONFIG_LINK_TO_ZLIB is 0!\n");
			return;
#endif
			original_in = in;

			// Uncompress the input as we read it.
			in = zlib_adapter::make_inflater(original_in);

			// Subtract the size of the 8-byte header, since
			// it's not included in the compressed
			// stream length.
			file_length -= 8;
		}

		stream	str(in);

		rect	frame_size;
		frame_size.read(&str);

		float	local_frame_rate = str.read_u16() / 256.0f;
		int	local_frame_count = str.read_u16();

		if (version) *version = local_version;
		if (width) *width = int(frame_size.width() / 20.0f + 0.5f);
		if (height) *height = int(frame_size.height() / 20.0f + 0.5f);
		if (frames_per_second) *frames_per_second = local_frame_rate;
		if (frame_count) *frame_count = local_frame_count;

		if (tag_count)
		{
			// Count tags.
			int local_tag_count = 0;
			while ((Uint32) str.get_position() < file_end_pos)
			{
				str.open_tag();
				str.close_tag();
				local_tag_count++;
			}
			*tag_count = local_tag_count;
		}

		delete in;
		delete original_in;
	}



	movie_definition*	create_movie(const char* filename)
	// Create the movie definition from the specified .swf file.
	{
		return create_movie_sub(filename);
	}


	movie_definition_sub*	create_movie_sub(const char* filename)
	{
		if (s_opener_function == NULL)
		{
			// Don't even have a way to open the file.
			log_error("error: no file opener function; can't create movie.  "
				  "See gameswf::register_file_opener_callback\n");
			return NULL;
		}

		tu_file* in = s_opener_function(filename);
		if (in == NULL)
		{
			log_error("failed to open '%s'; can't create movie.\n", filename);
			return NULL;
		}
		else if (in->get_error())
		{
			log_error("error: file opener can't open '%s'\n", filename);
			return NULL;
		}

		ensure_loaders_registered();

		movie_def_impl*	m = new movie_def_impl(DO_LOAD_BITMAPS, DO_LOAD_FONT_SHAPES);
		m->read(in);

		delete in;

		if (m && s_use_cache_files)
		{
			// Try to load a .gsc file.
			tu_string	cache_filename(filename);
			cache_filename += ".gsc";
			tu_file*	cache_in = s_opener_function(cache_filename.c_str());
			if (cache_in == NULL
			    || cache_in->get_error() != TU_FILE_NO_ERROR)
			{
				// Can't open cache file; don't sweat it.
				IF_VERBOSE_PARSE(log_msg("note: couldn't open cache file '%s'\n", cache_filename.c_str()));

				m->generate_font_bitmaps();	// can't read cache, so generate font texture data.
			}
			else
			{
				// Load the cached data.
				m->input_cached_data(cache_in);
			}

			delete cache_in;
		}

		m->add_ref();
		return m;
	}


	static bool	s_no_recurse_while_loading = false;	// @@ TODO get rid of this; make it the normal mode.


	movie_definition*	create_movie_no_recurse(
		tu_file* in,
		create_bitmaps_flag cbf,
		create_font_shapes_flag cfs)
	{
		ensure_loaders_registered();

		// @@ TODO make no_recurse the standard way to load.
		// In create_movie(), use the visit_ API to keep
		// visiting dependent movies, until everything is
		// loaded.  That way we only have one code path and
		// the resource_proxy stuff gets tested.
		s_no_recurse_while_loading = true;

		movie_def_impl*	m = new movie_def_impl(cbf, cfs);
		m->read(in);

		s_no_recurse_while_loading = false;

		m->add_ref();
		return m;
	}


	//
	// global gameswf management
	//


	// For built-in sprite ActionScript methods.
	as_object*	s_sprite_builtins = 0;	// shared among all sprites.
	static void	sprite_builtins_init();
	static void	sprite_builtins_clear();


	void	clear()
	// Maximum release of resources.
	{
		clear_library();
		sprite_builtins_clear();
		fontlib::clear();
		action_clear();
	}


	//
	// library stuff, for sharing resources among different movies.
	//


	static stringi_hash< smart_ptr<movie_definition_sub> >	s_movie_library;
	static hash< movie_definition_sub*, smart_ptr<movie_interface> >	s_movie_library_inst;
	static array<movie_interface*> s_extern_sprites;
	static movie_interface* s_current_root;

	static tu_string s_workdir;

	void save_extern_movie(movie_interface* m)
	{
		s_extern_sprites.push_back(m);
	}

//#if 0
	void delete_unused_root()
	{
		for (int i = 0; i < s_extern_sprites.size(); i++)
		{
			movie_interface* root_m = s_extern_sprites[i];
			movie* m = root_m->get_root_movie();
      
			if (m->get_ref_count() < 2)
			{
				IF_VERBOSE_ACTION(log_msg("extern movie deleted\n"));
				s_extern_sprites.remove(i);
				i--;
				root_m->drop_ref();
			}
		}
	}
//#endif // 0

	movie_interface* get_current_root()
	{
		assert(s_current_root != NULL);
		return s_current_root;
	}

	void set_current_root(movie_interface* m)
	{