// Animates the mesh.
//
void prMesh_MD2::Animate()
{
if (mLoaded)
{
if (mpAnimation)
{
//mpAnimation->
mpAnimation->Update(16.0f/1000.0f);
m_frame = static_cast<prAnimation_MD2*>(mpAnimation)->GetFrame();
prTrace(prLogLevel::LogError, "Frame %i\n", m_frame);
}
}
}
/// ---------------------------------------------------------------------------
/// Plays a song.
/// ---------------------------------------------------------------------------
void prJNI_SongPlay(const char *filename)
{
JavaVM *pJavaVM = prJNI_GetVM();
PRASSERT(pJavaVM);
if (pJavaVM)
{
bool isAttached = false;
JNIEnv *env = NULL;
// Get environment.
if (!prJNI_GetEnv(&env, isAttached))
return;
// Find class
jclass cls = prJNI_GetAudioClass(env, "Music", isAttached);
if (!cls)
return;
// Find the callBack method ID
jmethodID method = env->GetStaticMethodID(cls, "songPlay", "(Ljava/lang/String;)V");
if (!method)
{
prTrace(LogError, "Failed to get method ID %s", "songPlay");
if (isAttached)
{
pJavaVM->DetachCurrentThread();
}
return;
}
// Construct a Java string.
jstring js = env->NewStringUTF(filename);
env->CallStaticVoidMethod(cls, method, js);
// And done
if (isAttached)
{
pJavaVM->DetachCurrentThread();
}
}
}
/// ---------------------------------------------------------------------------
/// Resumes playing the current song.
/// ---------------------------------------------------------------------------
void prJNI_SongResume()
{
JavaVM *pJavaVM = prJNI_GetVM();
PRASSERT(pJavaVM);
if (pJavaVM)
{
bool isAttached = false;
JNIEnv *env = NULL;
// Get environment.
if (!prJNI_GetEnv(&env, isAttached))
return;
// Find class
jclass cls = prJNI_GetAudioClass(env, "Music", isAttached);
if (!cls)
return;
// Find the callBack method ID
jmethodID method = env->GetStaticMethodID(cls, "songResume", "()V");
if (!method)
{
prTrace(LogError, "Failed to get method ID %s", "songResume");
if (isAttached)
{
pJavaVM->DetachCurrentThread();
}
return;
}
// Call.
env->CallStaticVoidMethod(cls, method);
// And done
if (isAttached)
{
pJavaVM->DetachCurrentThread();
}
}
}
/// ---------------------------------------------------------------------------
/// Plays a sound effect.
/// ---------------------------------------------------------------------------
s32 prSoundManager::SFXPlay(const char *name, f32 volume, bool loop)
{
s32 handle = -1;
#ifdef SOUND_ALLOW
PRASSERT(initialised && name && *name);
PRASSERT(pLoadedWaves);
if (numEffects > 0)
{
u32 hash = prStringHash(name);
for (s32 index = 0 ; index < numEffects; index++)
{
if (hash == pLoadedWaves[index].hash)
{
handle = SFXPlay(index, volume, loop);
break;
}
}
}
if (handle == -1)
{
prTrace(prLogLevel::LogWarning, "Failed to play effect '%s'\n", name);
}
#else
PRUNUSED(loop);
PRUNUSED(volume);
PRUNUSED(name);
#endif
return handle;
}
// Loads the mesh.
//
bool prMesh_MD2::Load(const char *filename)
{
// Loaded?
if (!mLoaded)
{
// Open the file
std::ifstream ifs(filename, std::ios::binary);
if (ifs.fail())
{
PRWARN("Failed to open model file %s", filename);
return false;
}
// Is the file too small?
ifs.seekg(0, std::ios::end);
int size = (int)ifs.tellg();
ifs.seekg(0, std::ios::beg);
if (size <= sizeof(prMD2Header))
{
PRWARN("File '%s' is not an MD2 file. It is too small", filename);
ifs.close();
return false;
}
// Load the header.
prMD2Header header;
if (ifs.read(reinterpret_cast<char*>(&header), sizeof(header)))
{
if (header.ident != MD2_MAGIC || header.version != MD2_VERSION)
{
PRWARN("File '%s' is not an MD2 file.", filename);
ifs.close();
return false;
}
// Display file details
#ifdef MD2_DEBUG
prTrace(prLogLevel::LogError, "-----------------------------------------\n");
prTrace(prLogLevel::LogError, "File : %s\n", filename );
prTrace(prLogLevel::LogError, "-----------------------------------------\n");
prTrace(prLogLevel::LogError, "Ident : %x\n", header.ident );
prTrace(prLogLevel::LogError, "Version : %i\n", header.version );
prTrace(prLogLevel::LogError, "Frames : %i\n", header.num_frames );
prTrace(prLogLevel::LogError, "commands : %i\n", header.num_glcmds );
prTrace(prLogLevel::LogError, "Triangles : %i\n", header.num_tris );
prTrace(prLogLevel::LogError, "Tex coords : %i\n", header.num_st );
prTrace(prLogLevel::LogError, "Vertices : %i\n", header.num_vertices );
prTrace(prLogLevel::LogError, "Textures : %i\n", header.num_skins );
prTrace(prLogLevel::LogError, "Tex width : %i\n", header.skinWidth );
prTrace(prLogLevel::LogError, "Tex height : %i\n", header.skinHeight );
prTrace(prLogLevel::LogError, "Frame size : %i\n", header.frameSize );
prTrace(prLogLevel::LogError, "-----------------------------------------\n");
#endif
// Memory allocation for model data
m_texCoords = new prMD2TexCoord [header.num_st];
m_triangles = new prMD2Triangle [header.num_tris];
m_frames = new prMD2Frame [header.num_frames];
m_glcmds = new int [header.num_glcmds];
// Read skin names
if (header.num_skins > 0)
{
m_skins = new prMD2Skin [header.num_skins];
ifs.seekg(header.offset_skins, std::ios::beg);
ifs.read(reinterpret_cast<char*>(m_skins), sizeof (prMD2Skin) * header.num_skins);
#ifdef MD2_DEBUG
for (int i=0; i<header.num_skins; i++)
{
prTrace(prLogLevel::LogError, "Skin: %s\n", m_skins[i].name);
char buffer[FILE_MAX_FILENAME_SIZE];
prStringCopySafe(buffer, m_skins[i].name, sizeof(buffer));
prTrace(prLogLevel::LogError, "Skin 1: %s\n", buffer);
prStringToLower(buffer);
prTrace(prLogLevel::LogError, "Skin 2: %s\n", buffer);
prStringReplaceChar(buffer, '\\', '/');
prTrace(prLogLevel::LogError, "Skin 3: %s\n", buffer);
s32 index = prStringFindLastIndex(buffer, '/');
if (index > 0)
{
prStringCopySafe(buffer, &buffer[index + 1], sizeof(buffer));
}
//prStringReplaceChar(buffer, '\\', '/');
prTrace(prLogLevel::LogError, "Skin 4: %s\n", buffer);
index = prStringFindLastIndex(buffer, '.');
if (index > 0)
{
buffer[index] = 0;
// prStringCopySafe(buffer, m_skins[i].name, sizeof(buffer));
}
prTrace(prLogLevel::LogError, "Skin 5: %s\n", buffer);
//else
//{
//}
prStringAddString(".pvr", buffer);
prTrace(prLogLevel::LogError, "Skin 6: %s\n", buffer);
char fullpath[FILE_MAX_FILENAME_SIZE];
sprintf(fullpath, "data/textures/%s", buffer);
prTrace(prLogLevel::LogError, "Texture: '%s'\n", fullpath);
// Load the texture
prResourceManager *pRM = static_cast<prResourceManager *>(prCoreGetComponent(PRSYSTEM_RESOURCEMANAGER));
if (pRM)
{
mpTexture = pRM->Load<prTexture>(fullpath);
//pRM->Load(fullpath);// >Unload((*it).texture);
}
}
#endif
}
else
{
prTrace(prLogLevel::LogError, "Model %s has no associated textures\n", filename);
}
// Read texture coords.
ifs.seekg(header.offset_st, std::ios::beg);
ifs.read(reinterpret_cast<char*>(m_texCoords), sizeof(prMD2TexCoord) * header.num_st);
// Read triangle data
ifs.seekg(header.offset_tris, std::ios::beg);
ifs.read(reinterpret_cast<char*>(m_triangles), sizeof(prMD2Triangle) * header.num_tris);
// Read frames
ifs.seekg(header.offset_frames, std::ios::beg);
for (int i=0; i<header.num_frames; i++)
{
// Memory allocation for the vertices of this frame
m_frames[i].verts = new prMD2Vertex[header.num_vertices];
// Read frame data
ifs.read(reinterpret_cast<char*>(&m_frames[i].scale), sizeof(prMD2Vec3));
ifs.read(reinterpret_cast<char*>(&m_frames[i].translate),sizeof(prMD2Vec3));
ifs.read(reinterpret_cast<char*>(&m_frames[i].name), sizeof(char) * 16);
ifs.read(reinterpret_cast<char*>( m_frames[i].verts), sizeof(prMD2Vertex) * header.num_vertices);
#ifdef MD2_DEBUG
prTrace(prLogLevel::LogError, "Name: %s\n", &m_frames[i].name);
#endif
}
// Read OpenGL commands
ifs.seekg(header.offset_glcmds, std::ios::beg);
ifs.read(reinterpret_cast<char*>(m_glcmds), sizeof(int) * header.num_glcmds);
// Store some of the header data.
m_numTriangles = header.num_tris;
m_skinWidth = header.skinWidth;
m_skinHeight = header.skinHeight;
m_numFrames = header.num_frames;
// Done.
mLoaded = true;
ifs.close();
// Create the animation data
if (m_numFrames > 0)
{
mpAnimation = new prAnimation_MD2(m_frames, m_numFrames);
}
}
else
{
PRWARN("Failed to load mesh '%s'.", filename);
}
}
return true;
}
/// ---------------------------------------------------------------------------
/// Constructor
/// ---------------------------------------------------------------------------
prEmitterDefinition::prEmitterDefinition(const char *name) : mHash (prStringHash(name))
, mName (name)
{
prTrace(LogError, "New 'prEmitterDefinition' %s - %08x\n", mName.c_str(), mHash);
}
