int Modify(int deltaWeight, size_t index) {
size_t remap = Indices[index];
int oldValue = Accum[remap];
int newValue = oldValue + deltaWeight;
Accum[remap] = newValue;
return Remap(newValue) - Remap(oldValue);
}
int GIFReadFrame(GifFileType* const gif, int transparent_index,
GIFFrameRect* const gif_rect, WebPPicture* const picture) {
WebPPicture sub_image;
const GifImageDesc* const image_desc = &gif->Image;
uint32_t* dst = NULL;
uint8_t* tmp = NULL;
int ok = 0;
GIFFrameRect rect = {
image_desc->Left, image_desc->Top, image_desc->Width, image_desc->Height
};
*gif_rect = rect;
// Use a view for the sub-picture:
if (!WebPPictureView(picture, rect.x_offset, rect.y_offset,
rect.width, rect.height, &sub_image)) {
fprintf(stderr, "Sub-image %dx%d at position %d,%d is invalid!\n",
rect.width, rect.height, rect.x_offset, rect.y_offset);
return 0;
}
dst = sub_image.argb;
tmp = (uint8_t*)malloc(rect.width * sizeof(*tmp));
if (tmp == NULL) goto End;
if (image_desc->Interlace) { // Interlaced image.
// We need 4 passes, with the following offsets and jumps.
const int interlace_offsets[] = { 0, 4, 2, 1 };
const int interlace_jumps[] = { 8, 8, 4, 2 };
int pass;
for (pass = 0; pass < 4; ++pass) {
int y;
for (y = interlace_offsets[pass]; y < rect.height;
y += interlace_jumps[pass]) {
if (DGifGetLine(gif, tmp, rect.width) == GIF_ERROR) goto End;
Remap(gif, tmp, rect.width, transparent_index,
dst + y * sub_image.argb_stride);
}
}
} else { // Non-interlaced image.
int y;
for (y = 0; y < rect.height; ++y) {
if (DGifGetLine(gif, tmp, rect.width) == GIF_ERROR) goto End;
Remap(gif, tmp, rect.width, transparent_index,
dst + y * sub_image.argb_stride);
}
}
ok = 1;
End:
if (!ok) picture->error_code = sub_image.error_code;
WebPPictureFree(&sub_image);
free(tmp);
return ok;
}
static int ReadSubImage(GifFileType* gif, WebPPicture* pic, WebPPicture* view) {
const GifImageDesc image_desc = gif->Image;
const int offset_x = image_desc.Left;
const int offset_y = image_desc.Top;
const int sub_w = image_desc.Width;
const int sub_h = image_desc.Height;
uint32_t* dst = NULL;
uint8_t* tmp = NULL;
int ok = 0;
// Use a view for the sub-picture:
if (!WebPPictureView(pic, offset_x, offset_y, sub_w, sub_h, view)) {
fprintf(stderr, "Sub-image %dx%d at position %d,%d is invalid!\n",
sub_w, sub_h, offset_x, offset_y);
goto End;
}
dst = view->argb;
tmp = (uint8_t*)malloc(sub_w * sizeof(*tmp));
if (tmp == NULL) goto End;
if (image_desc.Interlace) { // Interlaced image.
// We need 4 passes, with the following offsets and jumps.
const int interlace_offsets[] = { 0, 4, 2, 1 };
const int interlace_jumps[] = { 8, 8, 4, 2 };
int pass;
for (pass = 0; pass < 4; ++pass) {
int y;
for (y = interlace_offsets[pass]; y < sub_h; y += interlace_jumps[pass]) {
if (DGifGetLine(gif, tmp, sub_w) == GIF_ERROR) goto End;
Remap(tmp, gif, dst + y * view->argb_stride, sub_w);
}
}
} else { // Non-interlaced image.
int y;
for (y = 0; y < sub_h; ++y) {
if (DGifGetLine(gif, tmp, sub_w) == GIF_ERROR) goto End;
Remap(tmp, gif, dst + y * view->argb_stride, sub_w);
}
}
// re-align the view with even offset (and adjust dimensions if needed).
WebPPictureView(pic, offset_x & ~1, offset_y & ~1,
sub_w + (offset_x & 1), sub_h + (offset_y & 1), view);
ok = 1;
End:
free(tmp);
return ok;
}
// Read the GIF image frame.
static int ReadFrame(GifFileType* const gif, WebPFrameRect* const gif_rect,
WebPPicture* const sub_image, WebPPicture* const curr) {
const GifImageDesc image_desc = gif->Image;
uint32_t* dst = NULL;
uint8_t* tmp = NULL;
int ok = 0;
WebPFrameRect rect = {
image_desc.Left, image_desc.Top, image_desc.Width, image_desc.Height
};
*gif_rect = rect;
// Use a view for the sub-picture:
if (!WebPPictureView(curr, rect.x_offset, rect.y_offset,
rect.width, rect.height, sub_image)) {
fprintf(stderr, "Sub-image %dx%d at position %d,%d is invalid!\n",
rect.width, rect.height, rect.x_offset, rect.y_offset);
goto End;
}
dst = sub_image->argb;
tmp = (uint8_t*)malloc(rect.width * sizeof(*tmp));
if (tmp == NULL) goto End;
if (image_desc.Interlace) { // Interlaced image.
// We need 4 passes, with the following offsets and jumps.
const int interlace_offsets[] = { 0, 4, 2, 1 };
const int interlace_jumps[] = { 8, 8, 4, 2 };
int pass;
for (pass = 0; pass < 4; ++pass) {
int y;
for (y = interlace_offsets[pass]; y < rect.height;
y += interlace_jumps[pass]) {
if (DGifGetLine(gif, tmp, rect.width) == GIF_ERROR) goto End;
Remap(tmp, gif, dst + y * sub_image->argb_stride, rect.width);
}
}
} else { // Non-interlaced image.
int y;
for (y = 0; y < rect.height; ++y) {
if (DGifGetLine(gif, tmp, rect.width) == GIF_ERROR) goto End;
Remap(tmp, gif, dst + y * sub_image->argb_stride, rect.width);
}
}
ok = 1;
End:
free(tmp);
return ok;
}
int CDbxMdb::Load(bool bSkipInit)
{
if (!Remap())
return EGROKPRF_CANTREAD;
if (!bSkipInit) {
txn_ptr trnlck(m_pMdbEnv);
mdb_open(trnlck, "global", MDB_CREATE | MDB_INTEGERKEY, &m_dbGlobal);
mdb_open(trnlck, "contacts", MDB_CREATE | MDB_INTEGERKEY, &m_dbContacts);
mdb_open(trnlck, "modules", MDB_CREATE | MDB_INTEGERKEY, &m_dbModules);
mdb_open(trnlck, "events", MDB_CREATE | MDB_INTEGERKEY, &m_dbEvents);
mdb_open(trnlck, "eventsrt", MDB_CREATE | MDB_INTEGERKEY, &m_dbEventsSort);
mdb_open(trnlck, "settings", MDB_CREATE, &m_dbSettings);
DWORD keyVal = 1;
MDB_val key = { sizeof(DWORD), &keyVal }, data;
if (mdb_get(trnlck, m_dbGlobal, &key, &data) == MDB_SUCCESS) {
DBHeader *hdr = (DBHeader*)data.mv_data;
if (hdr->dwSignature != DBHEADER_SIGNATURE)
DatabaseCorruption(NULL);
memcpy(&m_header, data.mv_data, sizeof(m_header));
}
else {
m_header.dwSignature = DBHEADER_SIGNATURE;
m_header.dwVersion = 1;
data.mv_data = &m_header; data.mv_size = sizeof(m_header);
mdb_put(trnlck, m_dbGlobal, &key, &data, 0);
keyVal = 0;
DBContact dbc = { DBCONTACT_SIGNATURE, 0, 0, 0 };
data.mv_data = &dbc; data.mv_size = sizeof(dbc);
mdb_put(trnlck, m_dbContacts, &key, &data, 0);
}
trnlck.commit();
if (InitModuleNames()) return EGROKPRF_CANTREAD;
if (InitCrypt()) return EGROKPRF_CANTREAD;
// everything is ok, go on
if (!m_bReadOnly) {
// we don't need events in the service mode
if (ServiceExists(MS_DB_SETSAFETYMODE)) {
hContactDeletedEvent = CreateHookableEvent(ME_DB_CONTACT_DELETED);
hContactAddedEvent = CreateHookableEvent(ME_DB_CONTACT_ADDED);
hSettingChangeEvent = CreateHookableEvent(ME_DB_CONTACT_SETTINGCHANGED);
hEventMarkedRead = CreateHookableEvent(ME_DB_EVENT_MARKED_READ);
hEventAddedEvent = CreateHookableEvent(ME_DB_EVENT_ADDED);
hEventDeletedEvent = CreateHookableEvent(ME_DB_EVENT_DELETED);
hEventFilterAddedEvent = CreateHookableEvent(ME_DB_EVENT_FILTER_ADD);
}
}
FillContacts();
}
return ERROR_SUCCESS;
}
void CPCMRemap::Remap(void *data, void *out, unsigned int samples, long drc)
{
float gain = 1.0f;
if (drc > 0)
gain = pow(10.0f, (float)drc / 2000.0f);
Remap(data, out, samples, gain);
}
void Group::MakeExtrusionTopBottomFaces(IdList<Entity,hEntity> *el, hEntity pt)
{
if(pt.v == 0) return;
Group *src = SK.GetGroup(opA);
Vector n = src->polyLoops.normal;
Entity en;
ZERO(&en);
en.type = Entity::FACE_NORMAL_PT;
en.group = h;
en.numNormal = Quaternion::From(0, n.x, n.y, n.z);
en.point[0] = Remap(pt, REMAP_TOP);
en.h = Remap(Entity::NO_ENTITY, REMAP_TOP);
el->Add(&en);
en.point[0] = Remap(pt, REMAP_BOTTOM);
en.h = Remap(Entity::NO_ENTITY, REMAP_BOTTOM);
el->Add(&en);
}
STDMETHODIMP_(BOOL) CDbxMdb::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(szSetting);
int moduleNameLen = (int)strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(szModule);
strncpy_s(keySearch.szSettingName, szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
for (;; Remap()) {
txn_ptr trnlck(m_pMdbEnv);
if (mdb_del(trnlck, m_dbSettings, &key, &data))
return 1;
if (trnlck.commit())
break;
}
}
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
void Group::MakeExtrusionLines(IdList<Entity,hEntity> *el, hEntity in) {
Entity *ep = SK.GetEntity(in);
Entity en;
ZERO(&en);
if(ep->IsPoint()) {
// A point gets extruded to form a line segment
en.point[0] = Remap(ep->h, REMAP_TOP);
en.point[1] = Remap(ep->h, REMAP_BOTTOM);
en.group = h;
en.construction = ep->construction;
en.style = ep->style;
en.h = Remap(ep->h, REMAP_PT_TO_LINE);
en.type = Entity::LINE_SEGMENT;
el->Add(&en);
} else if(ep->type == Entity::LINE_SEGMENT) {
// A line gets extruded to form a plane face; an endpoint of the
// original line is a point in the plane, and the line is in the plane.
Vector a = SK.GetEntity(ep->point[0])->PointGetNum();
Vector b = SK.GetEntity(ep->point[1])->PointGetNum();
Vector ab = b.Minus(a);
en.param[0] = h.param(0);
en.param[1] = h.param(1);
en.param[2] = h.param(2);
en.numPoint = a;
en.numNormal = Quaternion::From(0, ab.x, ab.y, ab.z);
en.group = h;
en.construction = ep->construction;
en.style = ep->style;
en.h = Remap(ep->h, REMAP_LINE_TO_FACE);
en.type = Entity::FACE_XPROD;
el->Add(&en);
}
}
STDMETHODIMP_(BOOL) CDbxMdb::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
int settingNameLen = (int)strlen(szSetting);
int moduleNameLen = (int)strlen(szModule);
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(szModule);
strncpy_s(keySearch.szSettingName, szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
for (;; Remap())
{
txn_ptr trnlck(m_pMdbEnv);
MDB_CHECK(mdb_del(trnlck, m_dbSettings, &key, &data), 1);
if (trnlck.commit())
break;
}
}
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
bool FindDoc(docpos loBound, docpos hiBound, docpos &position) {
Heap.Clear();
assert(Heap.Clean());
for (size_t i = 0; i < Count; ++i) {
docpos pos = Iterators[i]->DocPos();
Heap.Add((pos << 16) + i);
Accum[i] = 0;
Free[i] = false;
}
int accum = 0;
assert(0 == Remap(0));
while (1) {
docpos foundDoc = loBound;
bool result = QuorumStep(loBound, hiBound, foundDoc, accum);
if (result) {
position = foundDoc;
return accum >= Quorum;
}
}
}
void Group::GenerateShellAndMesh(void) {
bool prevBooleanFailed = booleanFailed;
booleanFailed = false;
Group *srcg = this;
thisShell.Clear();
thisMesh.Clear();
runningShell.Clear();
runningMesh.Clear();
// Don't attempt a lathe or extrusion unless the source section is good:
// planar and not self-intersecting.
bool haveSrc = true;
if(type == EXTRUDE || type == LATHE) {
Group *src = SK.GetGroup(opA);
if(src->polyError.how != POLY_GOOD) {
haveSrc = false;
}
}
if(type == TRANSLATE || type == ROTATE) {
// A step and repeat gets merged against the group's prevous group,
// not our own previous group.
srcg = SK.GetGroup(opA);
GenerateForStepAndRepeat<SShell>(&(srcg->thisShell), &thisShell);
GenerateForStepAndRepeat<SMesh> (&(srcg->thisMesh), &thisMesh);
} else if(type == EXTRUDE && haveSrc) {
Group *src = SK.GetGroup(opA);
Vector translate = Vector::From(h.param(0), h.param(1), h.param(2));
Vector tbot, ttop;
if(subtype == ONE_SIDED) {
tbot = Vector::From(0, 0, 0); ttop = translate.ScaledBy(2);
} else {
tbot = translate.ScaledBy(-1); ttop = translate.ScaledBy(1);
}
SBezierLoopSetSet *sblss = &(src->bezierLoops);
SBezierLoopSet *sbls;
for(sbls = sblss->l.First(); sbls; sbls = sblss->l.NextAfter(sbls)) {
int is = thisShell.surface.n;
// Extrude this outer contour (plus its inner contours, if present)
thisShell.MakeFromExtrusionOf(sbls, tbot, ttop, color);
// And for any plane faces, annotate the model with the entity for
// that face, so that the user can select them with the mouse.
Vector onOrig = sbls->point;
int i;
for(i = is; i < thisShell.surface.n; i++) {
SSurface *ss = &(thisShell.surface.elem[i]);
hEntity face = Entity::NO_ENTITY;
Vector p = ss->PointAt(0, 0),
n = ss->NormalAt(0, 0).WithMagnitude(1);
double d = n.Dot(p);
if(i == is || i == (is + 1)) {
// These are the top and bottom of the shell.
if(fabs((onOrig.Plus(ttop)).Dot(n) - d) < LENGTH_EPS) {
face = Remap(Entity::NO_ENTITY, REMAP_TOP);
ss->face = face.v;
}
if(fabs((onOrig.Plus(tbot)).Dot(n) - d) < LENGTH_EPS) {
face = Remap(Entity::NO_ENTITY, REMAP_BOTTOM);
ss->face = face.v;
}
continue;
}
// So these are the sides
if(ss->degm != 1 || ss->degn != 1) continue;
Entity *e;
for(e = SK.entity.First(); e; e = SK.entity.NextAfter(e)) {
if(e->group.v != opA.v) continue;
if(e->type != Entity::LINE_SEGMENT) continue;
Vector a = SK.GetEntity(e->point[0])->PointGetNum(),
b = SK.GetEntity(e->point[1])->PointGetNum();
a = a.Plus(ttop);
b = b.Plus(ttop);
// Could get taken backwards, so check all cases.
if((a.Equals(ss->ctrl[0][0]) && b.Equals(ss->ctrl[1][0])) ||
(b.Equals(ss->ctrl[0][0]) && a.Equals(ss->ctrl[1][0])) ||
(a.Equals(ss->ctrl[0][1]) && b.Equals(ss->ctrl[1][1])) ||
(b.Equals(ss->ctrl[0][1]) && a.Equals(ss->ctrl[1][1])))
{
face = Remap(e->h, REMAP_LINE_TO_FACE);
ss->face = face.v;
break;
}
}
}
}
} else if(type == LATHE && haveSrc) {
Group *src = SK.GetGroup(opA);
Vector pt = SK.GetEntity(predef.origin)->PointGetNum(),
axis = SK.GetEntity(predef.entityB)->VectorGetNum();
axis = axis.WithMagnitude(1);
SBezierLoopSetSet *sblss = &(src->bezierLoops);
SBezierLoopSet *sbls;
for(sbls = sblss->l.First(); sbls; sbls = sblss->l.NextAfter(sbls)) {
thisShell.MakeFromRevolutionOf(sbls, pt, axis, color, this);
}
} else if(type == LINKED) {
// The imported shell or mesh are copied over, with the appropriate
// transformation applied. We also must remap the face entities.
Vector offset = {
SK.GetParam(h.param(0))->val,
SK.GetParam(h.param(1))->val,
SK.GetParam(h.param(2))->val };
Quaternion q = {
SK.GetParam(h.param(3))->val,
SK.GetParam(h.param(4))->val,
SK.GetParam(h.param(5))->val,
SK.GetParam(h.param(6))->val };
thisMesh.MakeFromTransformationOf(&impMesh, offset, q, scale);
thisMesh.RemapFaces(this, 0);
thisShell.MakeFromTransformationOf(&impShell, offset, q, scale);
thisShell.RemapFaces(this, 0);
}
if(srcg->meshCombine != COMBINE_AS_ASSEMBLE) {
thisShell.MergeCoincidentSurfaces();
}
// So now we've got the mesh or shell for this group. Combine it with
// the previous group's mesh or shell with the requested Boolean, and
// we're done.
Group *prevg = srcg->RunningMeshGroup();
if(prevg->runningMesh.IsEmpty() && thisMesh.IsEmpty() && !forceToMesh) {
SShell *prevs = &(prevg->runningShell);
GenerateForBoolean<SShell>(prevs, &thisShell, &runningShell,
srcg->meshCombine);
if(srcg->meshCombine != COMBINE_AS_ASSEMBLE) {
runningShell.MergeCoincidentSurfaces();
}
// If the Boolean failed, then we should note that in the text screen
// for this group.
booleanFailed = runningShell.booleanFailed;
if(booleanFailed != prevBooleanFailed) {
SS.ScheduleShowTW();
}
} else {
SMesh prevm, thism;
prevm = {};
thism = {};
prevm.MakeFromCopyOf(&(prevg->runningMesh));
prevg->runningShell.TriangulateInto(&prevm);
thism.MakeFromCopyOf(&thisMesh);
thisShell.TriangulateInto(&thism);
SMesh outm = {};
GenerateForBoolean<SMesh>(&prevm, &thism, &outm, srcg->meshCombine);
// And make sure that the output mesh is vertex-to-vertex.
SKdNode *root = SKdNode::From(&outm);
root->SnapToMesh(&outm);
root->MakeMeshInto(&runningMesh);
outm.Clear();
thism.Clear();
prevm.Clear();
}
displayDirty = true;
}
STDMETHODIMP_(BOOL) CDbxMdb::WriteContactSetting(MCONTACT contactID, DBCONTACTWRITESETTING *dbcws)
{
if (dbcws == NULL || dbcws->szSetting == NULL || dbcws->szModule == NULL || m_bReadOnly)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(dbcws->szSetting);
int moduleNameLen = (int)strlen(dbcws->szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
// used for notifications
DBCONTACTWRITESETTING dbcwNotif = *dbcws;
if (dbcwNotif.value.type == DBVT_WCHAR) {
if (dbcwNotif.value.pszVal != NULL) {
char* val = mir_utf8encodeW(dbcwNotif.value.pwszVal);
if (val == NULL)
return 1;
dbcwNotif.value.pszVal = (char*)alloca(strlen(val) + 1);
strcpy(dbcwNotif.value.pszVal, val);
mir_free(val);
dbcwNotif.value.type = DBVT_UTF8;
}
else return 1;
}
if (dbcwNotif.szModule == NULL || dbcwNotif.szSetting == NULL)
return 1;
DBCONTACTWRITESETTING dbcwWork = dbcwNotif;
mir_ptr<BYTE> pEncoded(NULL);
bool bIsEncrypted = false;
switch (dbcwWork.value.type) {
case DBVT_BYTE: case DBVT_WORD: case DBVT_DWORD:
break;
case DBVT_ASCIIZ: case DBVT_UTF8:
bIsEncrypted = m_bEncrypted || IsSettingEncrypted(dbcws->szModule, dbcws->szSetting);
LBL_WriteString:
if (dbcwWork.value.pszVal == NULL)
return 1;
dbcwWork.value.cchVal = (WORD)strlen(dbcwWork.value.pszVal);
if (bIsEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeString(dbcwWork.value.pszVal, &len);
if (pResult != NULL) {
pEncoded = dbcwWork.value.pbVal = pResult;
dbcwWork.value.cpbVal = (WORD)len;
dbcwWork.value.type = DBVT_ENCRYPTED;
}
}
break;
case DBVT_UNENCRYPTED:
dbcwNotif.value.type = dbcwWork.value.type = DBVT_UTF8;
goto LBL_WriteString;
case DBVT_BLOB: case DBVT_ENCRYPTED:
if (dbcwWork.value.pbVal == NULL)
return 1;
break;
default:
return 1;
}
mir_cslockfull lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(dbcwWork.szModule, dbcwWork.szSetting, moduleNameLen, settingNameLen);
// we don't cache blobs and passwords
if (dbcwWork.value.type != DBVT_BLOB && dbcwWork.value.type != DBVT_ENCRYPTED && !bIsEncrypted) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
bool bIsIdentical = false;
if (pCachedValue->type == dbcwWork.value.type) {
switch (dbcwWork.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == dbcwWork.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == dbcwWork.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == dbcwWork.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = strcmp(pCachedValue->pszVal, dbcwWork.value.pszVal) == 0; break;
}
if (bIsIdentical)
return 0;
}
m_cache->SetCachedVariant(&dbcwWork.value, pCachedValue);
}
if (szCachedSettingName[-1] != 0) {
lck.unlock();
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwWork);
return 0;
}
}
else m_cache->GetCachedValuePtr(contactID, szCachedSettingName, -1);
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbcws->szModule);
strncpy_s(keySearch.szSettingName, dbcws->szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
switch (dbcwWork.value.type) {
case DBVT_BYTE: data.mv_size = 2; break;
case DBVT_WORD: data.mv_size = 3; break;
case DBVT_DWORD: data.mv_size = 5; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
data.mv_size = 3 + dbcwWork.value.cchVal; break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
data.mv_size = 3 + dbcwWork.value.cpbVal; break;
}
for (;; Remap()) {
txn_ptr trnlck(m_pMdbEnv);
MDB_CHECK(mdb_put(trnlck, m_dbSettings, &key, &data, MDB_RESERVE), 1);
BYTE *pBlob = (BYTE*)data.mv_data;
*pBlob++ = dbcwWork.value.type;
switch (dbcwWork.value.type) {
case DBVT_BYTE: *pBlob = dbcwWork.value.bVal; break;
case DBVT_WORD: *(WORD*)pBlob = dbcwWork.value.wVal; break;
case DBVT_DWORD: *(DWORD*)pBlob = dbcwWork.value.dVal; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
data.mv_size = *(WORD*)pBlob = dbcwWork.value.cchVal;
pBlob += 2;
memcpy(pBlob, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
data.mv_size = *(WORD*)pBlob = dbcwWork.value.cpbVal;
pBlob += 2;
memcpy(pBlob, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
}
if (trnlck.commit())
break;
}
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
void Group::CopyEntity(IdList<Entity,hEntity> *el,
Entity *ep, int timesApplied, int remap,
hParam dx, hParam dy, hParam dz,
hParam qw, hParam qvx, hParam qvy, hParam qvz,
bool asTrans, bool asAxisAngle)
{
Entity en;
ZERO(&en);
en.type = ep->type;
en.extraPoints = ep->extraPoints;
en.h = Remap(ep->h, remap);
en.timesApplied = timesApplied;
en.group = h;
en.construction = ep->construction;
en.style = ep->style;
en.str.strcpy(ep->str.str);
en.font.strcpy(ep->font.str);
switch(ep->type) {
case Entity::WORKPLANE:
// Don't copy these.
return;
case Entity::POINT_N_COPY:
case Entity::POINT_N_TRANS:
case Entity::POINT_N_ROT_TRANS:
case Entity::POINT_N_ROT_AA:
case Entity::POINT_IN_3D:
case Entity::POINT_IN_2D:
if(asTrans) {
en.type = Entity::POINT_N_TRANS;
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
} else {
if(asAxisAngle) {
en.type = Entity::POINT_N_ROT_AA;
} else {
en.type = Entity::POINT_N_ROT_TRANS;
}
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
en.param[3] = qw;
en.param[4] = qvx;
en.param[5] = qvy;
en.param[6] = qvz;
}
en.numPoint = (ep->actPoint).ScaledBy(scale);
break;
case Entity::NORMAL_N_COPY:
case Entity::NORMAL_N_ROT:
case Entity::NORMAL_N_ROT_AA:
case Entity::NORMAL_IN_3D:
case Entity::NORMAL_IN_2D:
if(asTrans) {
en.type = Entity::NORMAL_N_COPY;
} else {
if(asAxisAngle) {
en.type = Entity::NORMAL_N_ROT_AA;
} else {
en.type = Entity::NORMAL_N_ROT;
}
en.param[0] = qw;
en.param[1] = qvx;
en.param[2] = qvy;
en.param[3] = qvz;
}
en.numNormal = ep->actNormal;
if(scale < 0) en.numNormal = en.numNormal.Mirror();
en.point[0] = Remap(ep->point[0], remap);
break;
case Entity::DISTANCE_N_COPY:
case Entity::DISTANCE:
en.type = Entity::DISTANCE_N_COPY;
en.numDistance = ep->actDistance*fabs(scale);
break;
case Entity::FACE_NORMAL_PT:
case Entity::FACE_XPROD:
case Entity::FACE_N_ROT_TRANS:
case Entity::FACE_N_TRANS:
case Entity::FACE_N_ROT_AA:
if(asTrans) {
en.type = Entity::FACE_N_TRANS;
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
} else {
if(asAxisAngle) {
en.type = Entity::FACE_N_ROT_AA;
} else {
en.type = Entity::FACE_N_ROT_TRANS;
}
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
en.param[3] = qw;
en.param[4] = qvx;
en.param[5] = qvy;
en.param[6] = qvz;
}
en.numPoint = (ep->actPoint).ScaledBy(scale);
en.numNormal = (ep->actNormal).ScaledBy(scale);
break;
default: {
int i, points;
bool hasNormal, hasDistance;
EntReqTable::GetEntityInfo(ep->type, ep->extraPoints,
NULL, &points, &hasNormal, &hasDistance);
for(i = 0; i < points; i++) {
en.point[i] = Remap(ep->point[i], remap);
}
if(hasNormal) en.normal = Remap(ep->normal, remap);
if(hasDistance) en.distance = Remap(ep->distance, remap);
break;
}
}
// If the entity came from an imported file where it was invisible then
// ep->actiVisble will be false, and we should hide it. Or if the entity
// came from a copy (e.g. step and repeat) of a force-hidden imported
// entity, then we also want to hide it.
en.forceHidden = (!ep->actVisible) || ep->forceHidden;
el->Add(&en);
}
int CDbxMdb::Create(void)
{
m_dwFileSize = 0;
return (Remap()) ? 0 : EGROKPRF_CANTREAD;
}
void aiPoints::cookSampleBody(Sample& sample)
{
auto& summary = getSummary();
auto& config = getConfig();
if (!summary.interpolate_points && !m_sample_index_changed)
return;
int point_count = (int)sample.m_points_sp->size();
if (m_sample_index_changed) {
if (m_sort) {
sample.m_sort_data.resize(point_count);
for (int i = 0; i < point_count; ++i) {
sample.m_sort_data[i].first = ((*sample.m_points_sp)[i] - getSortPosition()).length();
sample.m_sort_data[i].second = i;
}
#ifdef _WIN32
concurrency::parallel_sort
#else
std::sort
#endif
(sample.m_sort_data.begin(), sample.m_sort_data.end(),
[](const std::pair<float, int>& a, const std::pair<float, int>& b) { return a.first > b.first; });
Remap(sample.m_points, sample.m_points_sp, sample.m_sort_data);
if (summary.interpolate_points)
Remap(sample.m_points2, sample.m_points_sp2, sample.m_sort_data);
if (!summary.compute_velocities && sample.m_velocities_sp)
Remap(sample.m_velocities, sample.m_velocities_sp, sample.m_sort_data);
if (sample.m_ids_sp)
Remap(sample.m_ids, sample.m_ids_sp, sample.m_sort_data);
}
else {
Assign(sample.m_points, sample.m_points_sp, point_count);
if (summary.interpolate_points)
Assign(sample.m_points2, sample.m_points_sp2, point_count);
if (!summary.compute_velocities && sample.m_velocities_sp)
Assign(sample.m_velocities, sample.m_velocities_sp, point_count);
if (sample.m_ids_sp)
Assign(sample.m_ids, sample.m_ids_sp, point_count);
}
sample.m_points_ref = sample.m_points;
auto& config = getConfig();
if (config.swap_handedness) {
SwapHandedness(sample.m_points.data(), (int)sample.m_points.size());
SwapHandedness(sample.m_points2.data(), (int)sample.m_points2.size());
SwapHandedness(sample.m_velocities.data(), (int)sample.m_velocities.size());
}
if (config.scale_factor != 1.0f) {
ApplyScale(sample.m_points.data(), (int)sample.m_points.size(), config.scale_factor);
ApplyScale(sample.m_points2.data(), (int)sample.m_points2.size(), config.scale_factor);
ApplyScale(sample.m_velocities.data(), (int)sample.m_velocities.size(), config.scale_factor);
}
{
abcV3 bbmin, bbmax;
MinMax(bbmin, bbmax, sample.m_points.data(), (int)sample.m_points.size());
sample.m_bb_center = (bbmin + bbmax) * 0.5f;
sample.m_bb_size = bbmax - bbmin;
}
}
if (summary.interpolate_points) {
if (summary.compute_velocities)
sample.m_points_int.swap(sample.m_points_prev);
sample.m_points_int.resize_discard(sample.m_points.size());
Lerp(sample.m_points_int.data(), sample.m_points.data(), sample.m_points2.data(),
(int)sample.m_points.size(), m_current_time_offset);
sample.m_points_ref = sample.m_points_int;
if (summary.compute_velocities) {
sample.m_velocities.resize_discard(sample.m_points.size());
if (sample.m_points_int.size() == sample.m_points_prev.size()) {
GenerateVelocities(sample.m_velocities.data(), sample.m_points_int.data(), sample.m_points_prev.data(),
(int)sample.m_points_int.size(), config.vertex_motion_scale);
}
else {
sample.m_velocities.zeroclear();
}
}
}
}
void CGame::Draw()
{
Vector vecForward = m_hPlayer->GetGlobalView();
Vector vecUp(0, 1, 0);
// Cross-product http://www.youtube.com/watch?v=FT7MShdqK6w
Vector vecRight = vecUp.Cross(vecForward).Normalized();
CRenderer* pRenderer = GetRenderer();
// Tell the renderer how to set up the camera.
pRenderer->SetCameraPosition(m_hPlayer->GetGlobalOrigin() - vecForward * 6 + vecUp * 3 - vecRight * 0.5f);
pRenderer->SetCameraDirection(vecForward);
pRenderer->SetCameraUp(Vector(0, 1, 0));
pRenderer->SetCameraFOV(90);
pRenderer->SetCameraNear(0.1f);
pRenderer->SetCameraFar(1000);
// This rendering context is a tool for rendering things to the screen.
// All of our drawing commands are part of it.
CRenderingContext r(pRenderer);
// Clear the depth buffer and set a background color.
r.ClearDepth();
r.ClearColor(Color(210, 230, 255));
// CRenderer::StartRendering() - This function sets up OpenGL with the
// camera information that we passed it before.
pRenderer->StartRendering(&r);
m_oFrameFrustum = CFrustum(r.GetProjection() * r.GetView());
// First tell OpenGL what "shader" or "program" to use.
r.UseProgram("model");
// Set the sunlight direction. The y component is -1 so the light is pointing down.
Vector vecSunlight = Vector(1, -1, 1).Normalized();
// Uncomment this code to make the sunlight rotate:
//Vector vecSunlight = Vector(cos(Game()->GetTime()), -1, sin(Game()->GetTime())).Normalized();
r.SetUniform("vecSunlight", vecSunlight);
r.SetUniform("bLighted", false);
r.SetUniform("bDiffuse", false);
// Render the ground.
r.SetUniform("vecColor", Vector4D(0.6f, 0.7f, 0.9f, 1));
r.SetUniform("vecCameraPosition", GetRenderer()->GetCameraPosition());
r.BeginRenderTriFan();
r.Normal(Vector(0, 1, 0));
r.Tangent(Vector(1, 0, 0));
r.Bitangent(Vector(0, 0, 1));
r.TexCoord(Vector2D(0, 1));
r.Vertex(Vector(-30, 0, -30));
r.TexCoord(Vector2D(0, 0));
r.Vertex(Vector(-30, 0, 30));
r.TexCoord(Vector2D(1, 0));
r.Vertex(Vector(30, 0, 30));
r.TexCoord(Vector2D(1, 1));
r.Vertex(Vector(30, 0, -30));
r.EndRender();
r.SetUniform("bLighted", true);
// Prepare a list of entities to render.
m_apRenderOpaqueList.clear();
m_apRenderTransparentList.clear();
for (size_t i = 0; i < MAX_CHARACTERS; i++)
{
CCharacter* pCharacter = GetCharacterIndex(i);
if (!pCharacter)
continue;
// We need to scale the AABB using the character's scale values before we can use it to calculate our center/radius.
AABB aabbSizeWithScaling = pCharacter->m_aabbSize * pCharacter->m_vecScaling;
Vector vecCharacterCenter = pCharacter->GetGlobalOrigin() + aabbSizeWithScaling.GetCenter();
float flCharacterRadius = aabbSizeWithScaling.GetRadius();
// If the entity is outside the viewing frustum then the player can't see it - don't draw it.
// http://youtu.be/4p-E_31XOPM
if (!m_oFrameFrustum.SphereIntersection(vecCharacterCenter, flCharacterRadius))
continue;
if (pCharacter->m_bDrawTransparent)
m_apRenderTransparentList.push_back(pCharacter);
else
m_apRenderOpaqueList.push_back(pCharacter);
}
// Draw all opaque characters first.
DrawCharacters(m_apRenderOpaqueList, false);
for (size_t i = 0; i < MAX_CHARACTERS; i++)
{
CCharacter* pCharacter = GetCharacterIndex(i);
if (!pCharacter)
continue;
if (!pCharacter->m_bEnemyAI)
continue;
float flRadius = 3.5f;
Vector vecIndicatorOrigin = NearestPointOnSphere(m_hPlayer->GetGlobalOrigin(), flRadius, pCharacter->GetGlobalOrigin());
float flBoxSize = 0.1f;
r.SetUniform("vecColor", Color(255, 0, 0, 255));
r.RenderBox(vecIndicatorOrigin - Vector(1, 1, 1)*flBoxSize, vecIndicatorOrigin + Vector(1, 1, 1)*flBoxSize);
}
// Sort the transparent render list so that we paint the items farther from the camera first. http://youtu.be/fEjZrwDKdi8
MergeSortTransparentRenderList();
// Now draw all transparent characters, sorted by distance from the camera.
DrawCharacters(m_apRenderTransparentList, true);
r.SetUniform("bDiffuse", false);
// Render any bullet tracers that may have been created.
float flBulletTracerTime = 0.1f;
for (size_t i = 0; i < Game()->GetTracers().size(); i++)
{
if (Game()->GetTime() < Game()->GetTracers()[i].flTimeCreated + flBulletTracerTime)
{
Vector vecStart = Game()->GetTracers()[i].vecStart;
Vector vecEnd = Game()->GetTracers()[i].vecEnd;
r.SetUniform("vecColor", Vector4D(1, 0.9f, 0, 1));
r.BeginRenderLines();
r.Normal(Vector(0, 1, 0));
r.Vertex(vecStart);
r.Vertex(vecEnd);
r.EndRender();
}
}
// Render any puffs that may have been created.
float flPuffTime = 0.3f;
for (size_t i = 0; i < Game()->GetPuffs().size(); i++)
{
if (Game()->GetTime() < Game()->GetPuffs()[i].flTimeCreated + flPuffTime)
{
float flTimeCreated = Game()->GetPuffs()[i].flTimeCreated;
float flTimeOver = Game()->GetPuffs()[i].flTimeCreated + flPuffTime;
float flStartSize = 0.2f;
float flEndSize = 2.0f;
float flSize = Remap(Game()->GetTime(), flTimeCreated, flTimeOver, flStartSize, flEndSize);
Vector vecOrigin = Game()->GetPuffs()[i].vecOrigin;
int iOrange = (int)Remap(Game()->GetTime(), flTimeCreated, flTimeOver, 0, 255);
r.SetUniform("vecColor", Color(255, iOrange, 0, 255));
r.RenderBox(vecOrigin - Vector(1, 1, 1)*flSize, vecOrigin + Vector(1, 1, 1)*flSize);
}
}
GraphDraw();
pRenderer->FinishRendering(&r);
// Call this last. Your rendered stuff won't appear on the screen until you call this.
Application()->SwapBuffers();
}
void CGame::GraphDraw()
{
CRenderingContext c(GetRenderer(), true);
for (int i = 0; i < m_Graph.GetNumNodes(); i++)
{
CGraph::CNode* node = m_Graph.GetNode(i);
{
if (m_iCurrentNode == i)
c.SetUniform("vecColor", Color(0, 255, 0, 255));
else if (node == m_pTargetNode)
c.SetUniform("vecColor", Color(255, 120, 0, 255));
else if (node->path_weight < 99999999999)
{
int r = (int)Remap(node->path_weight, 0, 10, 50, 255);
c.SetUniform("vecColor", Color(r, 50, 50, 255));
}
else
{
c.SetUniform("vecColor", Color(255, 255, 255, 255));
for (size_t j = 0; j < m_aiUnvisitedNodes.size(); j++)
{
if (m_aiUnvisitedNodes[j] == i)
{
c.SetUniform("vecColor", Color(0, 0, 255, 255));
break;
}
}
}
}
c.RenderBox(node->debug_position - Vector(1, 1, 1), node->debug_position + Vector(1, 1, 1));
if (node->seen)
{
c.SetUniform("vecColor", Color(0, 0, 0, 255));
c.RenderBox(node->debug_position + Vector(1, 1, -1) - Vector(0.2f, 0.2f, 0.2f), node->debug_position + Vector(1, 1, -1) + Vector(0.2f, 0.2f, 0.2f));
}
}
c.SetUniform("bLighted", false);
for (int i = 0; i < m_Graph.GetNumEdges(); i++)
{
CGraph::CEdge* edge = m_Graph.GetEdge(i);
CGraph::CNode* node1 = m_Graph.GetNode(edge->first);
CGraph::CNode* node2 = m_Graph.GetNode(edge->second);
bool in_path = false;
for (int j = 0; j < ((int)m_aiPathStack.size())-1; j++)
{
if (m_aiPathStack[j] == edge->first && m_aiPathStack[j+1] == edge->second)
{
in_path = true;
break;
}
if (m_aiPathStack[j] == edge->second && m_aiPathStack[j+1] == edge->first)
{
in_path = true;
break;
}
}
if (in_path)
c.SetUniform("vecColor", Color(0, 0, 255, 255));
else
c.SetUniform("vecColor", Color((int)Remap(edge->weight, 1, 8, 0, 255), 0, 0, 255));
c.BeginRenderLines();
c.Vertex(node1->debug_position + Vector(0, 0.1f, 0));
c.Vertex(node2->debug_position + Vector(0, 0.1f, 0));
c.EndRender();
Vector path_start, path_end;
bool show_path = false;
if (node1->path_from == edge->second)
{
path_start = node1->debug_position;
path_end = node2->debug_position;
show_path = true;
}
else if (node2->path_from == edge->first)
{
path_start = node2->debug_position;
path_end = node1->debug_position;
show_path = true;
}
if (show_path)
{
float lerp = fmod(GetTime(), 1);
Vector position = path_start * (1-lerp) + path_end * lerp;
c.RenderBox(position - Vector(0.2f, 0.2f, 0.2f), position + Vector(0.2f, 0.2f, 0.2f));
}
}
}