void psCharAppearance::ProcessAttach(csRef<iMeshWrapper> meshWrap, csRef<iSpriteCal3DSocket> socket)
{
if(!socket.IsValid())
return;
CS_ASSERT(socket.IsValid());
meshWrap->GetFlags().Set(CS_ENTITY_NODECAL);
const char* socketName = socket->GetName();
// Given a socket name of "righthand", we're looking for a key in the form of "socket_righthand"
csString keyName = "socket_";
keyName += socketName;
// Variables for transform to be specified
float trans_x = 0, trans_y = 0.0, trans_z = 0, rot_x = -PI/2, rot_y = 0, rot_z = 0;
csRef<iObjectIterator> it = meshWrap->GetFactory()->QueryObject()->GetIterator();
while ( it->HasNext() )
{
csRef<iKeyValuePair> key ( scfQueryInterface<iKeyValuePair> (it->Next()));
if (key && keyName == key->GetKey())
{
sscanf(key->GetValue(),"%f,%f,%f,%f,%f,%f",&trans_x,&trans_y,&trans_z,&rot_x,&rot_y,&rot_z);
}
}
meshWrap->QuerySceneNode()->SetParent( baseMesh->QuerySceneNode ());
socket->SetMeshWrapper( meshWrap );
socket->SetTransform( csTransform(csZRotMatrix3(rot_z)*csYRotMatrix3(rot_y)*csXRotMatrix3(rot_x), csVector3(trans_x,trans_y,trans_z)) );
usedSlots.PushSmart(socketName);
}
bool PawsManager::PlaySound(csRef<iSndSysData> sounddata)
{
if(!useSounds)
return true;
// If there is no sound loader or renderer, sound loading and playing will not be performed
if (!sounddata.IsValid() || !soundrenderer.IsValid() )
return false;
// Create a stream for this sound
csRef<iSndSysStream> sndstream=soundrenderer->CreateStream(sounddata,CS_SND3D_DISABLE);
if (!sndstream.IsValid())
return false;
// This stream should unregister (and all sources) automatically when it's done playing
sndstream->SetAutoUnregister(true);
// Create a source just for this sound.
csRef<iSndSysSource> source=soundrenderer->CreateSource(sndstream);
if (!source.IsValid())
{
soundrenderer->RemoveStream(sndstream);
return false;
}
source->SetVolume(volume);
sndstream->Unpause();
// Although we lose the reference, the CS sound renderer holds a reference to the source until playback is complete
return true;
}
void G2DTestSystemDriver::BlitTest ()
{
int w = myG2D->GetWidth ();
int h = myG2D->GetHeight ();
myG2D->SetClipRect(0,0,w,h);
myG2D->DrawBox(0,0,w,h, dsteel);
SetFont (fontItalic);
WriteCentered (0,-16*8, white, -1, "BLIT() TEST");
SetFont (fontLarge);
WriteCentered (0,-16*7, black, dsteel, "This will test whether iGraphics2D->Blit() works correctly");
WriteCentered (0,-16*6, black, dsteel, "on this canvas.");
WriteCentered (0,-16*4, black, dsteel, "You should see an image of an arrow and the word %s.",
CS::Quote::Double ("up"));
WriteCentered (0,-16*3, black, dsteel, "It is surrounded by a green rectangle, and the image");
WriteCentered (0,-16*2, black, dsteel, "itself has a black border. No red should be visible");
WriteCentered (0,-16*1, black, dsteel, "and the border has to be complete, too.");
if (blitTestImage.IsValid ())
{
const int imW = blitTestImage->GetWidth ();
const int imH = blitTestImage->GetHeight ();
const int bx = (w - imW) / 2;
const int by = h / 2;
DrawClipRect (bx, by, imW + 1, imH + 1);
myG2D->Blit (bx + 1, by + 1, imW, imH,
(unsigned char*)blitTestImage->GetImageData ());
}
}
void G2DTestSystemDriver::DrawAlphaTestScreen ()
{
int w = myG2D->GetWidth ();
int h = myG2D->GetHeight ();
myG2D->SetClipRect(0,0,w,h);
myG2D->DrawBox(0,0,w,h, dsteel);
SetFont (fontItalic);
WriteCentered (1, 1, white, -1, "ALPHA COLOR TEST");
SetFont (fontLarge);
WriteCentered (1, 16*2, black, -1, "If your current canvas is in 32-bit mode, you should");
WriteCentered (1, 16*3, black, -1, "see various text and geometry at various transparencies.");
myG2D->DrawBox (190, 80, 50, 100, black);
myG2D->DrawBox (20, 100, 150, 75, myG2D->FindRGB (205, 0, 125, 200));
myG2D->DrawBox (120, 100, 100, 50, myG2D->FindRGB (120, 50, 50, 100));
myG2D->DrawLine (30, 110, 120, 60, myG2D->FindRGB (255, 128, 128, 128));
myG2D->DrawLine (120, 60, 70, 120, myG2D->FindRGB (128, 255, 128, 128));
myG2D->DrawLine (70, 120, 30, 110, myG2D->FindRGB (128, 128, 255, 128));
if (alphaBlitImage.IsValid ())
{
myG2D->Blit (20, 160, alphaBlitImage->GetWidth (), alphaBlitImage->GetHeight (),
(unsigned char*)alphaBlitImage->GetImageData ());
}
myG2D->Write (font, 50, 140, myG2D->FindRGB (255, 255, 255, 100), -1,
L"Here is some partially transparent text");
myG2D->Write (font, 50, 150, myG2D->FindRGB (0, 0, 255, 150), -1,
L"overlaying partially transparent boxes.");
csString str;
int i;
int y = 140;
int tw, th;
font->GetMaxSize (tw, th);
for (i = 0; i < 6; i++)
{
const uint8 alpha = (i * 51);
str.Format ("FG has alpha %" PRIu8 , alpha);
myG2D->Write (font, 320, y, MakeColor (255, 255, 255, alpha),
black, str);
y += th;
str.Format ("BG has alpha %" PRIu8, alpha);
myG2D->Write (font, 320, y, white, MakeColor (0, 0, 0, alpha),
str);
y += th;
}
}
csRef<iString> csGetPluginMetadata (const char* fullPath,
csRef<iDocument>& metadata)
{
// @@@ There's a small inefficiency here. This function, when given a
// filename of <blah>.dll or <blah>.csplugin, first checks <blah>.dll for
// embedded metadata and then for the existence of a <blah>.csplugin file.
// However, the csScanPluginDir() function already emits a <blah>.csplugin
// file name when such a file was found, <blah>.dll otherwise. This
// information can probably be reused.
CS_ALLOC_STACK_ARRAY (char, dllPath, strlen (fullPath) + 5);
strcpy (dllPath, fullPath);
char* dot = strrchr (dllPath, '.');
bool isCsPlugin = (dot && (strcasecmp (dot, ".csplugin") == 0));
if (!dot || isCsPlugin || strcasecmp (dot, ".dll") != 0)
{
if (isCsPlugin)
strcpy (dot, ".dll");
else
strcat (dllPath, ".dll");
}
csRef<iString> result;
metadata = 0;
#if defined(CS_EMBED_PLUGIN_META)
result = InternalGetPluginMetadata (dllPath, metadata);
#endif
// Check whether a .csplugin file exists as well
// @@@ This makes the assumption that such might only exists if this function
// was called with a <blah>.csplugin filename.
if (isCsPlugin)
{
csPhysicalFile file (fullPath, "rb");
if (file.GetStatus() == VFS_STATUS_OK)
{
if (metadata.IsValid())
{
csString errstr;
errstr.Format ("'%s' contains embedded metadata, "
"but external '%s' exists as well. Ignoring the latter.",
dllPath, fullPath);
result.AttachNew (new scfString (errstr));
}
else
{
csRef<iDocumentSystem> docsys =
csPtr<iDocumentSystem>(new csTinyDocumentSystem ());
csRef<iDocument> doc = docsys->CreateDocument();
char const* errmsg = doc->Parse (&file, true);
if (errmsg == 0) // Parse successful.
metadata = doc;
else // Parse failed.
{
csString errstr;
errstr.Format ("Error parsing metadata from '%s': %s",
fullPath, errmsg);
result.AttachNew (new scfString (errstr));
}
}
}
}
return result;
}
