/* Someone is required to call this (at worst) immediately before you spawn
* any threads. You can call this multiple times from the same thread, e.g.
* you can call it any number of times before any threads are spawned.
*/
void MPII_Get_global_init (void)
{
if (!initialized)
{
new_mutex (mutex);
initialized++;
}
}
/* You can *only* call this when either:
* - you have called MPII_Get_global_init() at least once
* - there is only one thread that could possibly call it at once
*/
void *MPII_Get_global (Key **key, int size, void *init)
{
void *ptr;
if (*key == (Key *) 0)
{
int mpi_init;
MPI_Initialized (&mpi_init);
if (mpi_init)
{
if (!initialized)
{
new_mutex (mutex);
initialized++;
}
lock (mutex);
}
if (*key == (Key *) 0) /* still */
{
*key = (Key *) malloc (sizeof (Key));
new_tsd (**key);
}
if (mpi_init)
unlock (mutex);
}
ptr = get_tsd (**key);
if (ptr == (void *) 0)
{
ptr = (void *) malloc (size);
if (ptr == (void *) 0)
{
perror ("g2tsd: MPII_Get_global: malloc failed");
exit (1);
}
memcpy (ptr, init, size);
set_tsd (**key, ptr);
}
return ptr;
}
void quake3_bsp_map::convert_and_load_textures() {
typedef vector<quake3_texture>::iterator quake3_texture_iterator;
vector<string> extensions;
extensions.push_back(".tga");
extensions.push_back(".jpg");
m_textures.resize(m_raw_texture_data.size());
int i = 0;
for (quake3_texture_iterator texture = m_raw_texture_data.begin();
texture != m_raw_texture_data.end(); ++texture) {
string filename_to_check = (*texture).file;
//We search the listed extensions above to find an available file,
//If the file is not available loading will fail (it will look for a file
//without an extension). This is fine.
for (vector<string>::const_iterator ext = extensions.begin();
ext != extensions.end(); ++ext) {
if (get_owning_resource_manager()->is_file_available(filename_to_check + (*ext))) {
filename_to_check += (*ext);
break;
}
}
shared_ptr<boost::mutex> new_mutex(new boost::mutex());
shared_ptr<resource_interface> new_texture(new devil_texture());
//Load the textures asynchronously
resource_id id = get_owning_resource_manager()->queue_file_for_loading(
filename_to_check, new_texture, new_mutex);
m_textures[i++].set_resource_id(id);
//TODO: copy other texture stuff across
}
}
/**
* new_packetizer_b()
* etch_packetizer private constructor
* @param transport the transport interface of the next lower layer of the stack,
* that being the connection, e.g. etch_tcp_connection. not owned.
* @param maxpktsize maximum number of bytes in a packet (default currently 10240)
*/
etch_packetizer* new_packetizer_b (i_transportdata* itd, const int maxpktsize)
{
etch_packetizer* packetizer = NULL;
i_transport* itransport = NULL;
i_session* isession = NULL;
etch_mutex* mutex = NULL;
int result = -1;
ETCH_ASSERT(is_etch_transportdata(itd));
do
{
#if(ETCHPZR_HAS_MUTEX)
if (NULL == (mutex = new_mutex(etch_apr_mempool, ETCHMUTEX_NESTED))) break;
#endif
/* - - - - - - - - - - - - - - -
* etch_packetizer
* - - - - - - - - - - - - - - -
*/
packetizer = (etch_packetizer*) new_object
(sizeof(etch_packetizer), ETCHTYPEB_PACKETIZER, CLASSID_PACKETIZER);
((etch_object*)packetizer)->destroy = destroy_packetizer;
((etch_object*)packetizer)->clone = clone_null;
packetizer->datalock = mutex;
packetizer->headersize = ETCH_PKTIZER_HEADERSIZE;
packetizer->is_wantheader = TRUE;
packetizer->maxpacketsize = maxpktsize > 0? maxpktsize: ETCH_PKTIZER_DEFMAXPKTSIZE;
packetizer->savebuf = new_flexbuffer(ETCH_DEFSIZE); /* 2K default */
/* set our transport to that of next lower layer (connection) */
packetizer->transport = itd; /* not owned */
/* - - - - - - - - - - - - - - -
* i_transportpacket
* - - - - - - - - - - - - - - -
*/
itransport = new_transport_interface_ex (packetizer,
(etch_transport_control) etch_pktizer_transport_control,
(etch_transport_notify) etch_pktizer_transport_notify,
(etch_transport_query) etch_pktizer_transport_query,
etch_pktizer_get_session,
etch_pktizer_set_session);
/* instantiate i_transportpacket interface which packetizer implements */
packetizer->transportpkt = new_transportpkt_interface (packetizer,
etch_pktizer_transport_packet,
itransport); /* transportpkt now owns itransport */
/* copy i_transportpacket interface methods up to packetizer */
packetizer->transport_packet = etch_pktizer_transport_packet;
packetizer->transport_control = itransport->transport_control;
packetizer->transport_notify = itransport->transport_notify;
packetizer->transport_query = itransport->transport_query;
packetizer->get_session = itransport->get_session;
packetizer->set_session = itransport->set_session;
/* - - - - - - - - - - - - - - -
* i_sessiondata
* - - - - - - - - - - - - - - -
*/
isession = new_session_interface (packetizer,
(etch_session_control) etch_pktizer_session_control,
(etch_session_notify) etch_pktizer_session_notify,
(etch_session_query) etch_pktizer_session_query);
/* instantiate i_sessiondata interface which packetizer implements */
packetizer->sessiondata = new_sessiondata_interface(packetizer,
etch_pktizer_session_data,
isession); /* sessiondata now owns isession */
/* copy session interface to parent */
packetizer->session_data = etch_pktizer_session_data;
packetizer->session_control = isession->session_control;
packetizer->session_notify = isession->session_notify;
packetizer->session_query = isession->session_query;
/* finally set session of next lower layer (tcp connection) to our session */
/* fyi we must pass the implementor of transport as thisx, i.e. tcpconnection */
packetizer->transport->set_session (packetizer->transport->thisx, packetizer->sessiondata);
result = 0;
} while(0);
if (-1 == result) {
etch_object_destroy(packetizer);
packetizer = NULL;
}
return packetizer;
}
