void ModelPhysics::insert(ModelInstance & modelInst,
f32 mass,
f32 friction,
vec3 linearFactor,
vec3 angularFactor,
u32 group,
const ivec4 & mask03,
const ivec4 & mask47)
{
if (mBodies.find(modelInst.model().uid()) == mBodies.end())
{
ASSERT(modelInst.mHasBody == false);
vec3 halfExtents = modelInst.model().gmdl().halfExtents();
auto colShapeIt = mCollisionShapes.find(halfExtents);
btVector3 btExtents(halfExtents.x, halfExtents.y, halfExtents.z);
btCollisionShape * pCollisionShape = nullptr;
if (colShapeIt != mCollisionShapes.end())
pCollisionShape = colShapeIt->second.get();
else
{
auto empRes = mCollisionShapes.emplace(std::piecewise_construct,
std::forward_as_tuple(halfExtents),
std::forward_as_tuple(GNEW(kMEM_Physics, btBoxShape, btExtents)));
pCollisionShape = empRes.first->second.get();
}
ModelMotionState * pMotionState = GNEW(kMEM_Physics, ModelMotionState, modelInst);
btRigidBody::btRigidBodyConstructionInfo constrInfo(mass, pMotionState, pCollisionShape);
constrInfo.m_friction = friction;
// constrInfo.m_angularDamping = 0.1;
// constrInfo.m_localInertia = btExtents;
ModelBody * pBody = GNEW(kMEM_Physics, ModelBody, pMotionState, group, constrInfo);
mBodies.emplace(modelInst.model().uid(), pBody);
pBody->setLinearFactor(btVector3(linearFactor.x, linearFactor.y, linearFactor.z));
pBody->setAngularFactor(btVector3(angularFactor.x, angularFactor.y, angularFactor.z));
if (group == 0)
{
mpDynamicsWorld->addRigidBody(pBody);
}
else
{
u16 groupMask = maskFromHash(group);
u16 mask = buildMask(mask03, mask47);
mpDynamicsWorld->addRigidBody(pBody, maskFromHash(group), buildMask(mask03, mask47));
}
pBody->setGravity(btVector3(0,0,0));
}
else
{
LOG_ERROR("ModelBody for %u already created", modelInst.model().uid());
}
}
i32 sprite_create(AssetHandleP pAssetHandle, i32 stageHash, i32 passHash, const mat43 & transform, Entity * pCaller)
{
ASSERT(pAssetHandle->typeHash() == HASH::asset);
const Asset * pAsset = pAssetHandle->data<Asset>();
Sprite * pSprite = GNEW(kMEM_Engine, Sprite, pCaller->task().id(), pAsset);
SpriteInstance * pSpriteInst = GNEW(kMEM_Engine, SpriteInstance, pSprite, stageHash, pass_from_hash(passHash), transform);
SpriteInstance::sprite_insert(pCaller->task().id(), kSpriteMgrTaskId, pSpriteInst);
return pSprite->uid();
}
VOID Editor::Open(const GData* data)
{
if(mMapPtr) mMapPtr.Release();
mMapPtr = GNEW(EMap); CHECK(mMapPtr);
mMapPtr->Load(data);
// set the brush
mBrushPtr = GNEW(BrushLozenge(mMapPtr.Ptr()));
CHECK(mBrushPtr);
mBrushPtr->Name("map/brick.tga");
mBrushPtr->Radius(1.0f);
mBrushPtr->Strength(0.5f);
mBrushPtr->Softness(1.0f);
}
GAudio::GAudio() : mDevice(NULL), mContext(NULL), mChannels(NULL)
{
// open the device
mDevice = alcOpenDevice(NULL);
if(mDevice==NULL) GAssert("GAudio: could not open the al device!.");
// create a context
ALCint caps[] =
{
ALC_FREQUENCY, 44100,
ALC_STEREO_SOURCES, 4,
0, 0
};
mContext = alcCreateContext(mDevice, caps);
if(mContext==NULL) GAssert("GAudio: could not create a al context.");
CHECK(alcMakeContextCurrent(mContext));
// initialize channels.
mChannels = GNEW(GAudioSource[MAX_AUDIO_CHANNELS]);
CHECK(mChannels);
for(U32 i = 0; i < MAX_AUDIO_CHANNELS; i++)
{
mFrees.push_back(&mChannels[i]);
}
// use our own distance model.
alDistanceModel(AL_NONE);
}
Constant::Constant(I32 n)
{
mType = CT_INT;
mData = GNEW(U8[sizeof(I32)]); CHECK(mData);
mCount = 1;
*((I32*)mData) = n;
}
static edgelistitem *mkItem(Dt_t * d, edgelistitem * obj, Dtdisc_t * disc)
{
edgelistitem *ap = GNEW(edgelistitem);
ap->edge = obj->edge;
return ap;
}
/*
* John M. suggests:
* You might want to add four more:
*
* _ohdraw_ (optional head-end arrow for edges)
* _ohldraw_ (optional head-end label for edges)
* _otdraw_ (optional tail-end arrow for edges)
* _otldraw_ (optional tail-end label for edges)
*
* that would be generated when an additional option is supplied to
* dot, etc. and
* these would be the arrow/label positions to use if a user want to flip the
* direction of an edge (as sometimes is there want).
*
* N.B. John M. asks:
* By the way, I don't know if you ever plan to add other letters for
* the xdot spec, but could you reserve "a" and also "A" (for attribute),
* "n" and also "N" (for numeric), "w" (for sWitch), "s" (for string)
* and "t" (for tooltip) and "x" (for position). We use those letters in
* our drawing spec (and also "<" and ">"), so if you start generating
* output with them, it could break what we have.
*/
static void
xdot_begin_graph (graph_t *g, int s_arrows, int e_arrows, format_type id)
{
int i, us;
char* s;
xd = GNEW(xdot_state_t);
if (id == FORMAT_XDOT14) {
xd->version = 14;
xd->version_s = "1.4";
}
else if (id == FORMAT_XDOT12) {
xd->version = 12;
xd->version_s = "1.2";
}
else if ((s = agget(g, "xdotversion")) && s[0] && ((us = versionStr2Version(s)) > 10)) {
xd->version = us;
xd->version_s = s;
}
else {
xd->version = versionStr2Version(XDOTVERSION);
xd->version_s = XDOTVERSION;
}
if (GD_n_cluster(g))
#ifndef WITH_CGRAPH
xd->g_draw = safe_dcl(g, g, "_draw_", "", agraphattr);
#else
xd->g_draw = safe_dcl(g, AGRAPH, "_draw_", "");
#endif
else
/* list is alpha sorted by type, the quality sorted within the type,
then, if qualities are the same, last install wins */
bool gvplugin_install(GVC_t * gvc, api_t api,
char *typestr, int quality, char *packagename, char *path,
gvplugin_installed_t * typeptr)
{
gvplugin_available_t *plugin, **pnext;
if (api < 0)
return FALSE;
/* point to the beginning of the linked list of plugins for this api */
pnext = &(gvc->apis[api]);
/* keep alpha-sorted and insert new duplicates ahead of old */
while (*pnext && strcmp(typestr, (*pnext)->typestr) > 0)
pnext = &((*pnext)->next);
/* keep quality sorted within type and inster new duplicates ahead of old */
while (*pnext && strcmp(typestr, (*pnext)->typestr) == 0 && quality < (*pnext)->quality)
pnext = &((*pnext)->next);
plugin = GNEW(gvplugin_available_t);
plugin->next = *pnext;
*pnext = plugin;
plugin->typestr = typestr;
plugin->quality = quality;
plugin->packagename = packagename; /* packagename, all packages */
plugin->path = path; /* filepath for .so, or NULL for builtins */
plugin->typeptr = typeptr; /* null if not loaded */
return TRUE;
}
Constant::Constant(F32 f)
{
mType = CT_FLOAT;
mData = GNEW(U8[sizeof(F32)]); CHECK(mData);
mCount = 1;
*((F32*)mData) = f;
}
Constant::Constant(const Vector4& vec)
{
mType = CT_VECTOR;
mData = GNEW(U8[sizeof(Vector4)]); CHECK(mData);
mCount = 1;
*((Vector4*)mData) = vec;
}
static nsitem_t *mkItem(Dt_t * d, nsitem_t * obj, Dtdisc_t * disc)
{
nsitem_t *ap = GNEW(nsitem_t);
ap->np = obj->np;
return ap;
}
/*
====================
Load
====================
*/
VOID Map2D::Load(const GData* data)
{
GUARD(Map2D::Load);
CHECK(data);
U8*data_ptr = (U8*)data->Ptr();
// check the map header
CHECK(*(U32*)data_ptr == (MAKEFOURCC('G','M','A','P')));
data_ptr += sizeof(U32);
// get the stride of the map
mWidth = *(U32*)data_ptr;
data_ptr += sizeof(U32);
mHeight = *(U32*)data_ptr;
data_ptr += sizeof(U32);
// load all of the chunks
for(U32 j = 0; j < mHeight; j++)
{
for(U32 i = 0; i < mWidth; i++)
{
Chunk2DPtr chunk = GNEW(Chunk2D); CHECK(chunk);
chunk->Load(data_ptr);
mChunks.push_back(chunk);
}
}
UNGUARD;
}
Constant::Constant(const Matrix& mat)
{
mType = CT_MATRIX;
mData = GNEW(U8[sizeof(Matrix)]); CHECK(mData);
mCount = 1;
*((Matrix*)mData) = mat;
}
CMajEnv *initConstrainedMajorization(float *packedMat, int n,
int *ordering, int *levels,
int num_levels)
{
int i, level = -1, start_of_level_above = 0;
CMajEnv *e = GNEW(CMajEnv);
e->A = NULL;
e->n = n;
e->ordering = ordering;
e->levels = levels;
e->num_levels = num_levels;
e->A = unpackMatrix(packedMat, n);
e->lev = N_GNEW(n, int);
for (i = 0; i < e->n; i++) {
if (i >= start_of_level_above) {
level++;
start_of_level_above =
(level == num_levels) ? e->n : levels[level];
}
e->lev[ordering[i]] = level;
}
e->fArray1 = N_GNEW(n, float);
e->fArray2 = N_GNEW(n, float);
e->fArray3 = N_GNEW(n, float);
e->fArray4 = N_GNEW(n, float);
e->iArray1 = N_GNEW(n, int);
e->iArray2 = N_GNEW(n, int);
e->iArray3 = N_GNEW(n, int);
e->iArray4 = N_GNEW(n, int);
return e;
}
static degitem *mkItem(Dt_t * d, degitem * obj, Dtdisc_t * disc)
{
degitem *ap = GNEW(degitem);
ap->np = NULL;
ap->deg = obj->deg;
return ap;
}
Constant::Constant(const I32* pn, U32 count)
{
CHECK(pn);
mType = CT_INT_ARRAY;
mData = GNEW(U8[count*sizeof(I32)]); CHECK(mData);
mCount = count;
::memcpy(mData,pn,count*sizeof(I32));
}
Constant::Constant(const Matrix* pmat, U32 count)
{
CHECK(pmat);
mType = CT_MATRIX_ARRAY;
mData = GNEW(U8[count*sizeof(Matrix)]); CHECK(mData);
mCount = count;
::memcpy(mData,pmat,count*sizeof(Matrix));
}
Constant::Constant(const Vector4* pvec, U32 count)
{
CHECK(pvec);
mType = CT_VECTOR_ARRAY;
mData = GNEW(U8[count*sizeof(Vector4)]); CHECK(mData);
mCount = count;
::memcpy(mData,pvec,count*sizeof(Vector4));
}
Constant::Constant(const F32* pf, U32 count)
{
CHECK(pf);
mType = CT_FLOAT_ARRAY;
mData = GNEW(U8[count*sizeof(F32)]); CHECK(mData);
mCount = count;
::memcpy(mData,pf,count*sizeof(F32));
}
/*
====================
Update
====================
*/
VOID EChunk::Update()
{
GUARD(EChunk::Update);
// erase the layer that is invalid
std::vector<Layer>::iterator it = mLayers.begin();
while(it != mLayers.end())
{
Layer& layer = (*it);
if(layer.total==0)
{
it = mLayers.erase(it);
}
else
{
++it;
}
}
// update the alpha texture
U32 width = U2P(ALPHA_STRIDE);
U32 height = U2P(ALPHA_STRIDE);
for(I32 k = 0; k < mLayers.size(); k++)
{
Layer& layer = mLayers[k];
Image* image = GNEW(Image); CHECK(image);
image->Width(width);
image->Height(height);
image->PixelFormat(PF_ALPHA);
image->DataType(DT_UNSIGNED_BYTE);
image->MipmapCount(1);
if(k==0)
{
image->Mipmap(0,NULL,width*height*sizeof(U8));
U8* data = (U8*)image->Mipmap(0);
for(U32 j = 0; j < height; j++)
{
for( U32 i = 0; i < width; i++)
{
U8& alpha = layer.alpha[i+j*width];
U8& mask = mMask[i+j*width];
if(mask == 0) data[i+j*width] = (U8)(((F32)alpha)/255.0f*127.0f);
else data[i+j*width] = (U8)(((F32)alpha)/255.0f*127.0f)+128;
}
}
layer.texture->Load(image);
layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "base");
}
else
{
image->Mipmap(0,&layer.alpha[0],width*height*sizeof(U8));
layer.texture->Load(image);
layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "layer");
}
}
UNGUARD;
}
PointMap *newPM(void)
{
MPairDisc *dp = GNEW(MPairDisc);
dp->disc = intMPairDisc;
dp->flist = 0;
return (dtopen(&(dp->disc), Dtoset));
}
ModelPhysics::ModelPhysics()
{
mTimePrev = mTimeCurr = now();
mpBroadphase = GNEW(kMEM_Physics, btDbvtBroadphase);
mpCollisionConfiguration = GNEW(kMEM_Physics, btDefaultCollisionConfiguration);
mpDispatcher = GNEW(kMEM_Physics, btCollisionDispatcher, mpCollisionConfiguration);
mpDispatcher->setNearCallback(near_callback);
mpSolver = GNEW(kMEM_Physics, btSequentialImpulseConstraintSolver);
mpDynamicsWorld = GNEW(kMEM_Physics,
btDiscreteDynamicsWorld,
mpDispatcher,
mpBroadphase,
mpSolver,
mpCollisionConfiguration);
}
/* mkTriGraph:
* Generate graph with triangles as nodes and an edge iff two triangles
* share an edge.
*/
static tgraph *mkTriGraph(surface_t * sf, int maxv, pointf * pts)
{
tgraph *g;
tnode *np;
int j, i, ne = 0;
int *edgei;
int *jp;
/* ne is twice no. of edges */
for (i = 0; i < 3 * sf->nfaces; i++)
if (sf->neigh[i] != -1)
ne++;
g = GNEW(tgraph);
/* plus 2 for nodes added as endpoints of an edge */
g->nodes = N_GNEW(sf->nfaces + 2, tnode);
/* allow 1 possible extra edge per triangle, plus
* obstacles can have at most maxv triangles touching
*/
edgei = N_GNEW(sf->nfaces + ne + 2 * maxv, int);
g->edges = N_GNEW(ne/2 + 2 * maxv, tedge);
g->nedges = 0;
for (i = 0; i < sf->nfaces; i++) {
np = g->nodes + i;
np->ne = 0;
np->edges = edgei;
np->ctr = triCenter(pts, sf->faces + 3 * i);
edgei += degT(sf->neigh + 3 * i) + 1;
}
/* initialize variable nodes */
np = g->nodes + i;
np->ne = 0;
np->edges = edgei;
np++;
np->ne = 0;
np->edges = edgei + maxv;
for (i = 0; i < sf->nfaces; i++) {
np = g->nodes + i;
jp = sf->neigh + 3 * i;
ne = 0;
while ((ne < 3) && ((j = *jp++) != -1)) {
if (i < j) {
double dist = DIST(np->ctr, (g->nodes + j)->ctr);
ipair seg =
sharedEdge(sf->faces + 3 * i, sf->faces + 3 * j);
addTriEdge(g, i, j, dist, seg);
}
ne++;
}
}
return g;
}
/*
====================
bind
====================
*/
VOID Game::bind(U32 fbo)
{
GUARD(Game::bind);
// build the fbo
mNullRTPtr = GNEW(Target(fbo));
CHECK(mNullRTPtr);
UNGUARD;
}
static cluster_data* cluster_map(graph_t *mastergraph, graph_t *g)
{
/* search meta-graph to find clusters */
graph_t *mg, *subg;
node_t *mm, *mn;
node_t *n;
edge_t *me;
/* array of arrays of node indices in each cluster */
int **cs,*cn;
int i,j,nclusters=0;
bool* assigned = N_NEW(agnnodes(g), bool);
cluster_data *cdata = GNEW(cluster_data);
cdata->ntoplevel = agnnodes(g);
mm = mastergraph->meta_node;
mg = mm->graph;
for (me = agfstout(mg, mm); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
if (!strncmp(subg->name, "cluster", 7)) {
nclusters++;
}
}
cdata->nvars=0;
cdata->nclusters = nclusters;
cs = cdata->clusters = N_GNEW(nclusters,int*);
cn = cdata->clustersizes = N_GNEW(nclusters,int);
/* fprintf(stderr,"search %d clusters...\n",nclusters); */
for (me = agfstout(mg, mm); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
/* clusters are processed by separate calls to ordered_edges */
if (!strncmp(subg->name, "cluster", 7)) {
int *c;
*cn = agnnodes(subg);
cdata->nvars += *cn;
c = *cs++ = N_GNEW(*cn++,int);
/* fprintf(stderr,"Cluster with %d nodes...\n",agnnodes(subg)); */
for (n = agfstnode(subg); n; n = agnxtnode(subg, n)) {
node_t *gn;
int ind = 0;
for (gn = agfstnode(g); gn; gn = agnxtnode(g, gn)) {
if(gn->id==n->id) break;
ind++;
}
/* fprintf(stderr," node=%s, id=%d, ind=%d\n",n->name,n->id,ind); */
*c++=ind;
assigned[ind]=true;
cdata->ntoplevel--;
}
}
}
/*
====================
SetVector
====================
*/
VOID Constant::SetVector(const Vector4& vec)
{
if(mType == CT_NONE) mType = CT_VECTOR;
CHECK(mType == CT_VECTOR);
if(mCount != 1)
{
if(mData){ GDELETE([]mData), mData = NULL; }
mData = GNEW(U8[sizeof(Vector4)]); CHECK(mData);
mCount = 1;
}
*((Vector4*)mData) = vec;
}
/*
====================
SetMatrix
====================
*/
VOID Constant::SetMatrix(const Matrix& mat)
{
if(mType == CT_NONE) mType = CT_MATRIX;
CHECK(mType == CT_MATRIX);
if(mCount != 1)
{
if(mData){ GDELETE([]mData), mData = NULL; }
mData = GNEW(U8[sizeof(Matrix)]); CHECK(mData);
mCount = 1;
}
*((Matrix*)mData) = mat;
}
/* mkGrid:
* Create grid data structure.
* cellHint provides rough idea of how many cells
* may be needed.
*/
Grid *mkGrid(int cellHint)
{
Grid *g;
g = GNEW(Grid);
_grid = g; /* see comment above */
g->data = dtopen(&gridDisc, Dtoset);
g->listMem = 0;
g->listSize = 0;
g->cellMem = newBlock(cellHint);
return g;
}
/* newBlock:
* Create new block of size cells
*/
static block_t *newBlock(int size)
{
block_t *newb;
newb = GNEW(block_t);
newb->next = 0;
newb->mem = N_GNEW(size, cell);
newb->endp = newb->mem + size;
newb->cur = newb->mem;
return newb;
}
/*
====================
GLoad
====================
*/
const GData* GLoad(const CHAR* path)
{
GFile file;
file.Open(path);
U32 pos = file.Seek(0,FS_CUR);
U32 size = file.Seek(0,FS_END);
file.Seek(pos,FS_SET);
GData* data = GNEW(GData(size+1,0)); CHECK(data);
CHECK(file.Read(data->Ptr(),data->Size())==size);
file.Close();
return data;
}
