Bool
shadowSetup(ScreenPtr pScreen)
{
shadowBufPtr pBuf;
if (!DamageSetup(pScreen))
return FALSE;
if (shadowGeneration != serverGeneration) {
shadowScrPrivateIndex = AllocateScreenPrivateIndex();
if (shadowScrPrivateIndex == -1)
return FALSE;
shadowGeneration = serverGeneration;
}
pBuf = (shadowBufPtr) xalloc(sizeof(shadowBufRec));
if (!pBuf)
return FALSE;
#ifdef BACKWARDS_COMPATIBILITY
pBuf->pDamage = DamageCreate((DamageReportFunc)shadowReportFunc,
(DamageDestroyFunc)NULL,
DamageReportRawRegion,
TRUE, pScreen, pScreen);
#else
pBuf->pDamage = DamageCreate((DamageReportFunc)NULL,
(DamageDestroyFunc)NULL,
DamageReportNone,
TRUE, pScreen, pScreen);
#endif
if (!pBuf->pDamage) {
xfree(pBuf);
return FALSE;
}
wrap(pBuf, pScreen, CloseScreen);
wrap(pBuf, pScreen, GetImage);
pBuf->update = NULL;
pBuf->window = NULL;
pBuf->pPixmap = 0;
pBuf->closure = 0;
pBuf->randr = 0;
pBuf->ready_to_update = NULL;
#ifdef BACKWARDS_COMPATIBILITY
REGION_NULL(pScreen, &pBuf->damage); /* bc */
#endif
pScreen->devPrivates[shadowScrPrivateIndex].ptr = (pointer) pBuf;
return TRUE;
}
/**
* exaCreatePixmap() creates a new pixmap.
*
* If width and height are 0, this won't be a full-fledged pixmap and it will
* get ModifyPixmapHeader() called on it later. So, we mark it as pinned, because
* ModifyPixmapHeader() would break migration. These types of pixmaps are used
* for scratch pixmaps, or to represent the visible screen.
*/
static PixmapPtr
exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth)
{
PixmapPtr pPixmap;
ExaPixmapPrivPtr pExaPixmap;
int bpp;
ExaScreenPriv(pScreen);
if (w > 32767 || h > 32767)
return NullPixmap;
pPixmap = fbCreatePixmap (pScreen, w, h, depth);
if (!pPixmap)
return NULL;
pExaPixmap = ExaGetPixmapPriv(pPixmap);
bpp = pPixmap->drawable.bitsPerPixel;
/* Glyphs have w/h equal to zero, and may not be migrated. See exaGlyphs. */
if (!w || !h)
pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
else
pExaPixmap->score = EXA_PIXMAP_SCORE_INIT;
pExaPixmap->area = NULL;
pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
pExaPixmap->sys_pitch = pPixmap->devKind;
pExaPixmap->fb_ptr = NULL;
if (pExaScr->info->flags & EXA_OFFSCREEN_ALIGN_POT && w != 1)
pExaPixmap->fb_pitch = (1 << (exaLog2(w - 1) + 1)) * bpp / 8;
else
pExaPixmap->fb_pitch = w * bpp / 8;
pExaPixmap->fb_pitch = EXA_ALIGN(pExaPixmap->fb_pitch,
pExaScr->info->pixmapPitchAlign);
pExaPixmap->fb_size = pExaPixmap->fb_pitch * h;
if (pExaPixmap->fb_pitch > 131071) {
fbDestroyPixmap(pPixmap);
return NULL;
}
/* Set up damage tracking */
pExaPixmap->pDamage = DamageCreate (NULL, NULL, DamageReportNone, TRUE,
pScreen, pPixmap);
if (pExaPixmap->pDamage == NULL) {
fbDestroyPixmap (pPixmap);
return NULL;
}
DamageRegister (&pPixmap->drawable, pExaPixmap->pDamage);
DamageSetReportAfterOp (pExaPixmap->pDamage, TRUE);
/* None of the pixmap bits are valid initially */
REGION_NULL(pScreen, &pExaPixmap->validReg);
return pPixmap;
}
static int
ProcDamageCreate(ClientPtr client)
{
DrawablePtr pDrawable;
DamageExtPtr pDamageExt;
DamageReportLevel level;
RegionPtr pRegion;
REQUEST(xDamageCreateReq);
REQUEST_SIZE_MATCH(xDamageCreateReq);
LEGAL_NEW_RESOURCE(stuff->damage, client);
SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client,
SecurityReadAccess);
switch (stuff->level) {
case XDamageReportRawRectangles:
level = DamageReportRawRegion;
break;
case XDamageReportDeltaRectangles:
level = DamageReportDeltaRegion;
break;
case XDamageReportBoundingBox:
level = DamageReportBoundingBox;
break;
case XDamageReportNonEmpty:
level = DamageReportNonEmpty;
break;
default:
client->errorValue = stuff->level;
return BadValue;
}
pDamageExt = malloc(sizeof(DamageExtRec));
if (!pDamageExt)
return BadAlloc;
pDamageExt->id = stuff->damage;
pDamageExt->pDrawable = pDrawable;
pDamageExt->level = level;
pDamageExt->pClient = client;
pDamageExt->pDamage = DamageCreate(DamageExtReport,
DamageExtDestroy,
level,
FALSE, pDrawable->pScreen, pDamageExt);
if (!pDamageExt->pDamage) {
free(pDamageExt);
return BadAlloc;
}
if (!AddResource(stuff->damage, DamageExtType, (pointer) pDamageExt))
return BadAlloc;
DamageRegister(pDamageExt->pDrawable, pDamageExt->pDamage);
if (pDrawable->type == DRAWABLE_WINDOW) {
pRegion = &((WindowPtr) pDrawable)->borderClip;
DamageDamageRegion(pDrawable, pRegion);
}
return (client->noClientException);
}
Bool
shadowSetup(ScreenPtr pScreen)
{
shadowBufPtr pBuf;
if (!dixRegisterPrivateKey(&shadowScrPrivateKeyRec, PRIVATE_SCREEN, 0))
return FALSE;
if (!DamageSetup(pScreen))
return FALSE;
pBuf = malloc(sizeof(shadowBufRec));
if (!pBuf)
return FALSE;
#ifdef BACKWARDS_COMPATIBILITY
pBuf->pDamage = DamageCreate((DamageReportFunc) shadowReportFunc,
(DamageDestroyFunc) NULL,
DamageReportRawRegion, TRUE, pScreen, pScreen);
#else
pBuf->pDamage = DamageCreate((DamageReportFunc) NULL,
(DamageDestroyFunc) NULL,
DamageReportNone, TRUE, pScreen, pScreen);
#endif
if (!pBuf->pDamage) {
free(pBuf);
return FALSE;
}
wrap(pBuf, pScreen, CloseScreen);
wrap(pBuf, pScreen, GetImage);
pBuf->update = 0;
pBuf->window = 0;
pBuf->pPixmap = 0;
pBuf->closure = 0;
pBuf->randr = 0;
#ifdef BACKWARDS_COMPATIBILITY
RegionNull(&pBuf->damage); /* bc */
#endif
dixSetPrivate(&pScreen->devPrivates, shadowScrPrivateKey, pBuf);
return TRUE;
}
void FireFieldSpell::Launch() {
spells.endByCaster(m_caster, SPELL_FIRE_FIELD);
ARX_SOUND_PlaySFX(SND_SPELL_FIRE_FIELD_START);
m_duration = (m_launchDuration > ArxDuration(-1)) ? m_launchDuration : ArxDurationMs(100000);
m_hasDuration = true;
m_fManaCostPerSecond = 2.8f;
m_light = LightHandle();
Vec3f target;
float beta = 0.f;
bool displace = false;
if(m_caster == EntityHandle_Player) {
target = player.basePosition();
beta = player.angle.getYaw();
displace = true;
} else {
if(ValidIONum(m_caster)) {
Entity * io = entities[m_caster];
target = io->pos;
beta = io->angle.getYaw();
displace = (io->ioflags & IO_NPC) == IO_NPC;
} else {
ARX_DEAD_CODE();
}
}
if(displace) {
target += angleToVectorXZ(beta) * 250.f;
}
m_pos = target + Vec3f(0, -10, 0);
DamageParameters damage;
damage.radius = 150.f;
damage.damages = 10.f;
damage.area = DAMAGE_FULL;
damage.duration = ArxDurationMs(100000000);
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_FIRE | DAMAGE_TYPE_FIELD;
damage.pos = target;
m_damage = DamageCreate(damage);
m_snd_loop = ARX_SOUND_PlaySFX(SND_SPELL_FIRE_FIELD_LOOP, &target, 1.f, ARX_SOUND_PLAY_LOOPED);
pPSStream.SetParams(g_particleParameters[ParticleParam_FireFieldBase]);
pPSStream.SetPos(m_pos);
pPSStream1.SetParams(g_particleParameters[ParticleParam_FireFieldFlame]);
pPSStream1.SetPos(m_pos + Vec3f(0, 10, 0));
pPSStream1.Update(0);
}
static Bool
TegraCreateScreenResources(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
TegraPtr tegra = TegraPTR(pScrn);
PixmapPtr rootPixmap;
Bool ret;
void *pixels;
pScreen->CreateScreenResources = tegra->createScreenResources;
ret = pScreen->CreateScreenResources(pScreen);
pScreen->CreateScreenResources = TegraCreateScreenResources;
if (!drmmode_set_desired_modes(pScrn, &tegra->drmmode))
return FALSE;
drmmode_uevent_init(pScrn, &tegra->drmmode);
if (!tegra->drmmode.want_sw_cursor)
drmmode_map_cursor_bos(pScrn, &tegra->drmmode);
pixels = drmmode_map_front_bo(&tegra->drmmode);
if (!pixels)
return FALSE;
rootPixmap = pScreen->GetScreenPixmap(pScreen);
if (tegra->drmmode.shadow_enable)
pixels = tegra->drmmode.shadow_fb;
if (!pScreen->ModifyPixmapHeader(rootPixmap, -1, -1, -1, -1, -1, pixels))
FatalError("Couldn't adjust screen pixmap\n");
if (tegra->drmmode.shadow_enable) {
if (!shadowAdd(pScreen, rootPixmap, shadowUpdatePackedWeak(),
TegraShadowWindow, 0, 0))
return FALSE;
}
tegra->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE, pScreen,
rootPixmap);
if (tegra->damage) {
DamageRegister(&rootPixmap->drawable, tegra->damage);
tegra->dirty_enabled = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
} else {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Failed to create screen damage record\n");
return FALSE;
}
return ret;
}
Bool
ephyrSetInternalDamage(ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
PixmapPtr pPixmap = NULL;
scrpriv->pDamage = DamageCreate((DamageReportFunc) 0,
(DamageDestroyFunc) 0,
DamageReportNone, TRUE, pScreen, pScreen);
pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
DamageRegister(&pPixmap->drawable, scrpriv->pDamage);
return TRUE;
}
void PoisonProjectileSpell::Update(float timeDelta) {
for(size_t i = 0; i < m_projectiles.size(); i++) {
CPoisonProjectile * projectile = m_projectiles[i];
projectile->Update(timeDelta);
}
for(size_t i = 0; i < m_projectiles.size(); i++) {
CPoisonProjectile * projectile = m_projectiles[i];
projectile->Render();
if(lightHandleIsValid(projectile->lLightId)) {
EERIE_LIGHT * light = lightHandleGet(projectile->lLightId);
light->intensity = 2.3f * projectile->lightIntensityFactor;
light->fallend = 250.f;
light->fallstart = 150.f;
light->rgb = Color3f::green;
light->pos = projectile->eCurPos;
light->time_creation = (unsigned long)(arxtime);
light->duration = 200;
}
AddPoisonFog(projectile->eCurPos, m_level + 7);
if(m_timcreation + 1600 < (unsigned long)(arxtime)) {
DamageParameters damage;
damage.pos = projectile->eCurPos;
damage.radius = 120.f;
float v = 4.f + m_level * ( 1.0f / 10 ) * 6.f ;
damage.damages = v * ( 1.0f / 1000 ) * framedelay;
damage.area = DAMAGE_FULL;
damage.duration = static_cast<long>(framedelay);
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_POISON;
DamageCreate(damage);
}
}
}
Bool
saa_add_damage(PixmapPtr pixmap)
{
ScreenPtr pScreen = pixmap->drawable.pScreen;
struct saa_pixmap *spix = saa_get_saa_pixmap(pixmap);
if (spix->damage)
return TRUE;
spix->damage = DamageCreate(saa_report_damage, NULL,
DamageReportRawRegion, TRUE, pScreen, pixmap);
if (!spix->damage)
return FALSE;
DamageRegister(&pixmap->drawable, spix->damage);
DamageSetReportAfterOp(spix->damage, TRUE);
return TRUE;
}
void PoisonProjectileSpell::Update() {
for(size_t i = 0; i < m_projectiles.size(); i++) {
CPoisonProjectile * projectile = m_projectiles[i];
projectile->Update(g_gameTime.lastFrameDuration());
}
for(size_t i = 0; i < m_projectiles.size(); i++) {
CPoisonProjectile * projectile = m_projectiles[i];
projectile->Render();
EERIE_LIGHT * light = lightHandleGet(projectile->lLightId);
if(light) {
light->intensity = 2.3f * projectile->lightIntensityFactor;
light->fallend = 250.f;
light->fallstart = 150.f;
light->rgb = Color3f::green;
light->pos = projectile->eCurPos;
light->creationTime = g_gameTime.now();
light->duration = GameDurationMs(200);
}
AddPoisonFog(projectile->eCurPos, m_level + 7);
if(m_elapsed > GameDurationMs(1600)) {
DamageParameters damage;
damage.pos = projectile->eCurPos;
damage.radius = 120.f;
damage.damages = (4.f + m_level * 0.6f) * 0.001f * g_framedelay;
damage.area = DAMAGE_FULL;
damage.duration = g_gameTime.lastFrameDuration();
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_POISON;
DamageCreate(damage);
}
}
}
void CMultiMagicMissile::CheckCollision(float level, EntityHandle caster)
{
for(size_t i = 0; i < pTab.size(); i++) {
CMagicMissile * missile = (CMagicMissile *) pTab[i];
if(missile->bExplo)
continue;
Sphere sphere;
sphere.origin = missile->eCurPos;
sphere.radius = 10.f;
if(CheckAnythingInSphere(sphere, caster, CAS_NO_SAME_GROUP))
{
LaunchMagicMissileExplosion(missile->eCurPos, m_mrCheat);
ARX_NPC_SpawnAudibleSound(missile->eCurPos, entities[caster]);
missile->SetTTL(1000);
missile->bExplo = true;
missile->bMove = false;
missile->lLightId = LightHandle::Invalid;
DamageParameters damage;
damage.pos = missile->eCurPos;
damage.radius = 80.f;
damage.damages = (4 + level * ( 1.0f / 5 )) * .8f;
damage.area = DAMAGE_FULL;
damage.duration = -1;
damage.source = caster;
damage.flags = DAMAGE_FLAG_DONT_HURT_SOURCE;
damage.type = DAMAGE_TYPE_MAGICAL;
DamageCreate(damage);
Color3f rgb(.3f, .3f, .45f);
ARX_PARTICLES_Add_Smoke(&missile->eCurPos, 0, 6, &rgb);
}
}
}
Bool
ephyrSetInternalDamage(ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
PixmapPtr pPixmap = NULL;
scrpriv->pDamage = DamageCreate((DamageReportFunc) 0,
(DamageDestroyFunc) 0,
DamageReportNone, TRUE, pScreen, pScreen);
if (!RegisterBlockAndWakeupHandlers(ephyrInternalDamageBlockHandler,
ephyrInternalDamageWakeupHandler,
(void *) pScreen))
return FALSE;
pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
DamageRegister(&pPixmap->drawable, scrpriv->pDamage);
return TRUE;
}
Bool
omap_screen_resources_create(struct omap_screen_info *omaps)
{
PixmapPtr pixmap;
ENTER();
/* Set up our damage listener to update the window by hand. */
omaps->timer_active = 0;
omaps->empty_updates = 0;
omaps->damage = DamageCreate(damage_report_hook, damage_destroy_hook,
DamageReportNonEmpty, TRUE,
omaps->screen->pScreen, omaps);
if (!omaps->damage)
FatalError("omapCreateDrawResources: couldn't create damage\n");
pixmap = omaps->screen->pScreen->GetScreenPixmap(omaps->screen->pScreen);
if (!pixmap)
FatalError("omapCreateDrawResources: couldn't get screen pixmap\n");
omaps->pixmap = pixmap;
reset_damage(omaps);
DamageRegister(&pixmap->drawable, omaps->damage);
omaps->pixel_doubled = 0;
omaps->individual_updates = 0;
#ifdef XSP
XSPSetEventCallback(omaps->screen->pScreen->myNum, xsp_event, omaps);
#endif
omaps->tmp_region = REGION_CREATE(omaps->screen->pScreen, NullBox, 0);
if (!omaps->tmp_region)
FatalError("omapCreateDrawResources: couldn't create temp region\n");
LEAVE();
return TRUE;
}
Bool
xf86CrtcRotate(xf86CrtcPtr crtc)
{
ScrnInfoPtr pScrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
PictTransform crtc_to_fb;
struct pict_f_transform f_crtc_to_fb, f_fb_to_crtc;
xFixed *new_params = NULL;
int new_nparams = 0;
PictFilterPtr new_filter = NULL;
int new_width = 0;
int new_height = 0;
RRTransformPtr transform = NULL;
Bool damage = FALSE;
if (pScreen->isGPU)
return TRUE;
if (crtc->transformPresent)
transform = &crtc->transform;
if (!RRTransformCompute(crtc->x, crtc->y,
crtc->mode.HDisplay, crtc->mode.VDisplay,
crtc->rotation,
transform,
&crtc_to_fb,
&f_crtc_to_fb,
&f_fb_to_crtc) &&
xf86CrtcFitsScreen(crtc, &f_crtc_to_fb)) {
/*
* If the untranslated transformation is the identity,
* disable the shadow buffer
*/
xf86RotateDestroy(crtc);
crtc->transform_in_use = FALSE;
free(new_params);
new_params = NULL;
new_nparams = 0;
new_filter = NULL;
new_width = 0;
new_height = 0;
}
else {
if (crtc->driverIsPerformingTransform) {
xf86RotateDestroy(crtc);
}
else {
/*
* these are the size of the shadow pixmap, which
* matches the mode, not the pre-rotated copy in the
* frame buffer
*/
int width = crtc->mode.HDisplay;
int height = crtc->mode.VDisplay;
void *shadowData = crtc->rotatedData;
PixmapPtr shadow = crtc->rotatedPixmap;
int old_width = shadow ? shadow->drawable.width : 0;
int old_height = shadow ? shadow->drawable.height : 0;
/* Allocate memory for rotation */
if (old_width != width || old_height != height) {
if (shadow || shadowData) {
crtc->funcs->shadow_destroy(crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
shadowData = crtc->funcs->shadow_allocate(crtc, width, height);
if (!shadowData)
goto bail1;
crtc->rotatedData = shadowData;
/* shadow will be damaged in xf86RotatePrepare */
}
else {
/* mark shadowed area as damaged so it will be repainted */
damage = TRUE;
}
if (!xf86_config->rotation_damage) {
/* Create damage structure */
xf86_config->rotation_damage = DamageCreate(NULL, NULL,
DamageReportNone,
TRUE, pScreen,
pScreen);
if (!xf86_config->rotation_damage)
goto bail2;
/* Wrap block handler */
if (!xf86_config->BlockHandler) {
xf86_config->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = xf86RotateBlockHandler;
}
}
if (0) {
bail2:
if (shadow || shadowData) {
crtc->funcs->shadow_destroy(crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
bail1:
if (old_width && old_height)
crtc->rotatedPixmap =
crtc->funcs->shadow_create(crtc, NULL, old_width,
old_height);
return FALSE;
}
}
#ifdef RANDR_12_INTERFACE
if (transform) {
if (transform->nparams) {
new_params = malloc(transform->nparams * sizeof(xFixed));
if (new_params) {
memcpy(new_params, transform->params,
transform->nparams * sizeof(xFixed));
new_nparams = transform->nparams;
new_filter = transform->filter;
}
}
else
new_filter = transform->filter;
if (new_filter) {
new_width = new_filter->width;
new_height = new_filter->height;
}
}
#endif
crtc->transform_in_use = TRUE;
}
crtc->crtc_to_framebuffer = crtc_to_fb;
crtc->f_crtc_to_framebuffer = f_crtc_to_fb;
crtc->f_framebuffer_to_crtc = f_fb_to_crtc;
free(crtc->params);
crtc->params = new_params;
crtc->nparams = new_nparams;
crtc->filter = new_filter;
crtc->filter_width = new_width;
crtc->filter_height = new_height;
crtc->bounds.x1 = 0;
crtc->bounds.x2 = crtc->mode.HDisplay;
crtc->bounds.y1 = 0;
crtc->bounds.y2 = crtc->mode.VDisplay;
pixman_f_transform_bounds(&f_crtc_to_fb, &crtc->bounds);
if (damage)
xf86CrtcDamageShadow(crtc);
/* All done */
return TRUE;
}
/*
* Redirect one window for one client
*/
int
compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
{
CompWindowPtr cw = GetCompWindow(pWin);
CompClientWindowPtr ccw;
CompScreenPtr cs = GetCompScreen(pWin->drawable.pScreen);
WindowPtr pLayerWin = NULL;
Bool anyMarked = FALSE;
if (pWin == cs->pOverlayWin) {
return Success;
}
if (!pWin->parent)
return BadMatch;
/*
* Only one Manual update is allowed
*/
if (cw && update == CompositeRedirectManual)
for (ccw = cw->clients; ccw; ccw = ccw->next)
if (ccw->update == CompositeRedirectManual)
return BadAccess;
/*
* Allocate per-client per-window structure
* The client *could* allocate multiple, but while supported,
* it is not expected to be common
*/
ccw = malloc(sizeof(CompClientWindowRec));
if (!ccw)
return BadAlloc;
ccw->id = FakeClientID(pClient->index);
ccw->update = update;
/*
* Now make sure there's a per-window structure to hang this from
*/
if (!cw) {
cw = malloc(sizeof(CompWindowRec));
if (!cw) {
free(ccw);
return BadAlloc;
}
cw->damage = DamageCreate(compReportDamage,
compDestroyDamage,
DamageReportNonEmpty,
FALSE, pWin->drawable.pScreen, pWin);
if (!cw->damage) {
free(ccw);
free(cw);
return BadAlloc;
}
anyMarked = compMarkWindows(pWin, &pLayerWin);
RegionNull(&cw->borderClip);
cw->update = CompositeRedirectAutomatic;
cw->clients = 0;
cw->oldx = COMP_ORIGIN_INVALID;
cw->oldy = COMP_ORIGIN_INVALID;
cw->damageRegistered = FALSE;
cw->damaged = FALSE;
cw->pOldPixmap = NullPixmap;
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);
}
ccw->next = cw->clients;
cw->clients = ccw;
if (!AddResource(ccw->id, CompositeClientWindowType, pWin))
return BadAlloc;
if (ccw->update == CompositeRedirectManual) {
if (!anyMarked)
anyMarked = compMarkWindows(pWin, &pLayerWin);
if (cw->damageRegistered) {
DamageUnregister(&pWin->drawable, cw->damage);
cw->damageRegistered = FALSE;
}
cw->update = CompositeRedirectManual;
}
else if (cw->update == CompositeRedirectAutomatic && !cw->damageRegistered) {
if (!anyMarked)
anyMarked = compMarkWindows(pWin, &pLayerWin);
}
if (!compCheckRedirect(pWin)) {
FreeResource(ccw->id, RT_NONE);
return BadAlloc;
}
if (anyMarked)
compHandleMarkedWindows(pWin, pLayerWin);
return Success;
}
/**
* exaCreatePixmap() creates a new pixmap.
*
* If width and height are 0, this won't be a full-fledged pixmap and it will
* get ModifyPixmapHeader() called on it later. So, we mark it as pinned, because
* ModifyPixmapHeader() would break migration. These types of pixmaps are used
* for scratch pixmaps, or to represent the visible screen.
*/
PixmapPtr
exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
unsigned usage_hint)
{
PixmapPtr pPixmap;
ExaPixmapPrivPtr pExaPixmap;
BoxRec box;
int bpp;
ExaScreenPriv(pScreen);
if (w > 32767 || h > 32767)
return NullPixmap;
swap(pExaScr, pScreen, CreatePixmap);
pPixmap = pScreen->CreatePixmap(pScreen, w, h, depth, usage_hint);
swap(pExaScr, pScreen, CreatePixmap);
if (!pPixmap)
return NULL;
pExaPixmap = ExaGetPixmapPriv(pPixmap);
pExaPixmap->driverPriv = NULL;
bpp = pPixmap->drawable.bitsPerPixel;
pExaPixmap->driverPriv = NULL;
/* Scratch pixmaps may have w/h equal to zero, and may not be
* migrated.
*/
if (!w || !h)
pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
else
pExaPixmap->score = EXA_PIXMAP_SCORE_INIT;
pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
pExaPixmap->sys_pitch = pPixmap->devKind;
pPixmap->devPrivate.ptr = NULL;
pExaPixmap->use_gpu_copy = FALSE;
pExaPixmap->fb_ptr = NULL;
exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
pExaPixmap->fb_size = pExaPixmap->fb_pitch * h;
if (pExaPixmap->fb_pitch > 131071) {
swap(pExaScr, pScreen, DestroyPixmap);
pScreen->DestroyPixmap(pPixmap);
swap(pExaScr, pScreen, DestroyPixmap);
return NULL;
}
/* Set up damage tracking */
pExaPixmap->pDamage = DamageCreate(NULL, NULL,
DamageReportNone, TRUE,
pScreen, pPixmap);
if (pExaPixmap->pDamage == NULL) {
swap(pExaScr, pScreen, DestroyPixmap);
pScreen->DestroyPixmap(pPixmap);
swap(pExaScr, pScreen, DestroyPixmap);
return NULL;
}
DamageRegister(&pPixmap->drawable, pExaPixmap->pDamage);
/* This ensures that pending damage reflects the current operation. */
/* This is used by exa to optimize migration. */
DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
pExaPixmap->area = NULL;
/* We set the initial pixmap as completely valid for a simple reason.
* Imagine a 1000x1000 pixmap, it has 1 million pixels, 250000 of which
* could form single pixel rects as part of a region. Setting the complete region
* as valid is a natural defragmentation of the region.
*/
box.x1 = 0;
box.y1 = 0;
box.x2 = w;
box.y2 = h;
RegionInit(&pExaPixmap->validSys, &box, 0);
RegionInit(&pExaPixmap->validFB, &box, 0);
exaSetAccelBlock(pExaScr, pExaPixmap, w, h, bpp);
/* During a fallback we must prepare access. */
if (pExaScr->fallback_counter)
exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
return pPixmap;
}
/*
* Redirect one window for one client
*/
int
compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update)
{
CompWindowPtr cw = GetCompWindow (pWin);
CompClientWindowPtr ccw;
Bool wasMapped = pWin->mapped;
CompScreenPtr cs = GetCompScreen(pWin->drawable.pScreen);
if (pWin == cs->pOverlayWin) {
return Success;
}
if (!pWin->parent)
return BadMatch;
/*
* Only one Manual update is allowed
*/
if (cw && update == CompositeRedirectManual)
for (ccw = cw->clients; ccw; ccw = ccw->next)
if (ccw->update == CompositeRedirectManual)
return BadAccess;
/*
* Allocate per-client per-window structure
* The client *could* allocate multiple, but while supported,
* it is not expected to be common
*/
ccw = malloc(sizeof (CompClientWindowRec));
if (!ccw)
return BadAlloc;
ccw->id = FakeClientID (pClient->index);
ccw->update = update;
/*
* Now make sure there's a per-window structure to hang this from
*/
if (!cw)
{
cw = malloc(sizeof (CompWindowRec));
if (!cw)
{
free(ccw);
return BadAlloc;
}
cw->damage = DamageCreate (compReportDamage,
compDestroyDamage,
DamageReportNonEmpty,
FALSE,
pWin->drawable.pScreen,
pWin);
if (!cw->damage)
{
free(ccw);
free(cw);
return BadAlloc;
}
if (wasMapped)
{
DisableMapUnmapEvents (pWin);
UnmapWindow (pWin, FALSE);
EnableMapUnmapEvents (pWin);
}
RegionNull(&cw->borderClip);
cw->borderClipX = 0;
cw->borderClipY = 0;
cw->update = CompositeRedirectAutomatic;
cw->clients = 0;
cw->oldx = COMP_ORIGIN_INVALID;
cw->oldy = COMP_ORIGIN_INVALID;
cw->damageRegistered = FALSE;
cw->damaged = FALSE;
cw->pOldPixmap = NullPixmap;
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);
}
ccw->next = cw->clients;
cw->clients = ccw;
if (!AddResource (ccw->id, CompositeClientWindowType, pWin))
return BadAlloc;
if (ccw->update == CompositeRedirectManual)
{
/* If the window was CompositeRedirectAutomatic, then
* unmap the window so that the parent clip list will
* be correctly recomputed.
*/
if (pWin->mapped)
{
DisableMapUnmapEvents (pWin);
UnmapWindow (pWin, FALSE);
EnableMapUnmapEvents (pWin);
}
if (cw->damageRegistered)
{
DamageUnregister (&pWin->drawable, cw->damage);
cw->damageRegistered = FALSE;
}
cw->update = CompositeRedirectManual;
}
if (!compCheckRedirect (pWin))
{
FreeResource (ccw->id, RT_NONE);
return BadAlloc;
}
if (wasMapped && !pWin->mapped)
{
Bool overrideRedirect = pWin->overrideRedirect;
pWin->overrideRedirect = TRUE;
DisableMapUnmapEvents (pWin);
MapWindow (pWin, pClient);
EnableMapUnmapEvents (pWin);
pWin->overrideRedirect = overrideRedirect;
}
return Success;
}
void IceFieldSpell::Launch()
{
spells.endByCaster(m_caster, SPELL_ICE_FIELD);
ARX_SOUND_PlaySFX(SND_SPELL_ICE_FIELD);
m_duration = (m_launchDuration > -1) ? m_launchDuration : 100000;
m_hasDuration = true;
m_fManaCostPerSecond = 2.8f;
m_light = LightHandle::Invalid;
Vec3f target;
float beta = 0.f;
bool displace = false;
if(m_caster == PlayerEntityHandle) {
target = player.basePosition();
beta = player.angle.getPitch();
displace = true;
} else {
if(ValidIONum(m_caster)) {
Entity * io = entities[m_caster];
target = io->pos;
beta = io->angle.getPitch();
displace = (io->ioflags & IO_NPC) == IO_NPC;
} else {
ARX_DEAD_CODE();
}
}
if(displace) {
target += angleToVectorXZ(beta) * 250.f;
}
m_pos = target;
DamageParameters damage;
damage.radius = 150.f;
damage.damages = 10.f;
damage.area = DAMAGE_FULL;
damage.duration = 100000000;
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_COLD | DAMAGE_TYPE_FIELD;
damage.pos = target;
m_damage = DamageCreate(damage);
tex_p1 = TextureContainer::Load("graph/obj3d/textures/(fx)_tsu_blueting");
tex_p2 = TextureContainer::Load("graph/obj3d/textures/(fx)_tsu_bluepouf");
for(int i = 0; i < iMax; i++) {
float t = rnd();
if (t < 0.5f)
tType[i] = 0;
else
tType[i] = 1;
tSize[i] = Vec3f_ZERO;
tSizeMax[i] = Vec3f(rnd(), rnd(), rnd()) + Vec3f(0.f, 0.2f, 0.f);
Vec3f minPos;
if(tType[i] == 0) {
minPos = Vec3f(1.2f, 1, 1.2f);
} else {
minPos = Vec3f(0.4f, 0.3f, 0.4f);
}
tSizeMax[i] = glm::max(tSizeMax[i], minPos);
if(tType[i] == 0) {
tPos[i].x = m_pos.x + frand2() * 80;
tPos[i].y = m_pos.y;
tPos[i].z = m_pos.z + frand2() * 80;
} else {
tPos[i].x = m_pos.x + frand2() * 120;
tPos[i].y = m_pos.y;
tPos[i].z = m_pos.z + frand2() * 120;
}
}
m_snd_loop = ARX_SOUND_PlaySFX(SND_SPELL_ICE_FIELD_LOOP, &target, 1.f, ARX_SOUND_PLAY_LOOPED);
}
static int
ProcDamageCreate (ClientPtr client)
{
DrawablePtr pDrawable;
DamageExtPtr pDamageExt;
DamageReportLevel level;
RegionPtr pRegion;
int rc;
REQUEST(xDamageCreateReq);
REQUEST_SIZE_MATCH(xDamageCreateReq);
LEGAL_NEW_RESOURCE(stuff->damage, client);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixGetAttrAccess|DixReadAccess);
if (rc != Success)
return rc;
switch (stuff->level) {
case XDamageReportRawRectangles:
level = DamageReportRawRegion;
break;
case XDamageReportDeltaRectangles:
level = DamageReportDeltaRegion;
break;
case XDamageReportBoundingBox:
level = DamageReportBoundingBox;
break;
case XDamageReportNonEmpty:
level = DamageReportNonEmpty;
break;
default:
client->errorValue = stuff->level;
return BadValue;
}
pDamageExt = malloc(sizeof (DamageExtRec));
if (!pDamageExt)
return BadAlloc;
pDamageExt->id = stuff->damage;
pDamageExt->drawable = stuff->drawable;
pDamageExt->pDrawable = pDrawable;
pDamageExt->level = level;
pDamageExt->pClient = client;
pDamageExt->pDamage = DamageCreate (DamageExtReport,
DamageExtDestroy,
level,
FALSE,
pDrawable->pScreen,
pDamageExt);
if (!pDamageExt->pDamage)
{
free(pDamageExt);
return BadAlloc;
}
if (!AddResource (stuff->damage, DamageExtType, (pointer) pDamageExt))
return BadAlloc;
DamageSetReportAfterOp (pDamageExt->pDamage, TRUE);
DamageRegister (pDamageExt->pDrawable, pDamageExt->pDamage);
if (pDrawable->type == DRAWABLE_WINDOW)
{
pRegion = &((WindowPtr) pDrawable)->borderClip;
DamageDamageRegion(pDrawable, pRegion);
}
return Success;
}
Bool
xf86CrtcRotate (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation)
{
ScrnInfoPtr pScrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
ScreenPtr pScreen = pScrn->pScreen;
if (rotation == RR_Rotate_0)
{
/* Free memory from rotation */
if (crtc->rotatedPixmap || crtc->rotatedData)
{
crtc->funcs->shadow_destroy (crtc, crtc->rotatedPixmap, crtc->rotatedData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
if (xf86_config->rotation_damage)
{
/* Free damage structure */
DamageUnregister (&(*pScreen->GetScreenPixmap)(pScreen)->drawable,
xf86_config->rotation_damage);
xf86_config->rotation_damage_registered = FALSE;
DamageDestroy (xf86_config->rotation_damage);
xf86_config->rotation_damage = NULL;
/* Free block/wakeup handler */
RemoveBlockAndWakeupHandlers (xf86RotateBlockHandler,
xf86RotateWakeupHandler,
(pointer) pScreen);
}
}
else
{
/*
* these are the size of the shadow pixmap, which
* matches the mode, not the pre-rotated copy in the
* frame buffer
*/
int width = mode->HDisplay;
int height = mode->VDisplay;
void *shadowData = crtc->rotatedData;
PixmapPtr shadow = crtc->rotatedPixmap;
int old_width = shadow ? shadow->drawable.width : 0;
int old_height = shadow ? shadow->drawable.height : 0;
/* Allocate memory for rotation */
if (old_width != width || old_height != height)
{
if (shadow || shadowData)
{
crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
shadowData = crtc->funcs->shadow_allocate (crtc, width, height);
if (!shadowData)
goto bail1;
crtc->rotatedData = shadowData;
/* shadow will be damaged in xf86RotatePrepare */
}
else
{
/* mark shadowed area as damaged so it will be repainted */
xf86CrtcDamageShadow (crtc);
}
if (!xf86_config->rotation_damage)
{
/* Create damage structure */
xf86_config->rotation_damage = DamageCreate (NULL, NULL,
DamageReportNone,
TRUE, pScreen, pScreen);
if (!xf86_config->rotation_damage)
goto bail2;
/* Assign block/wakeup handler */
if (!RegisterBlockAndWakeupHandlers (xf86RotateBlockHandler,
xf86RotateWakeupHandler,
(pointer) pScreen))
{
goto bail3;
}
}
if (0)
{
bail3:
DamageDestroy (xf86_config->rotation_damage);
xf86_config->rotation_damage = NULL;
bail2:
if (shadow || shadowData)
{
crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
bail1:
if (old_width && old_height)
crtc->rotatedPixmap = crtc->funcs->shadow_create (crtc,
NULL,
old_width,
old_height);
return FALSE;
}
}
/* All done */
return TRUE;
}
void FireFieldSpell::Launch() {
spells.endByCaster(m_caster, SPELL_FIRE_FIELD);
ARX_SOUND_PlaySFX(SND_SPELL_FIRE_FIELD_START);
m_duration = (m_launchDuration > -1) ? m_launchDuration : 100000;
m_hasDuration = true;
m_fManaCostPerSecond = 2.8f;
m_light = LightHandle::Invalid;
Vec3f target;
float beta = 0.f;
bool displace = false;
if(m_caster == PlayerEntityHandle) {
target = player.basePosition();
beta = player.angle.getPitch();
displace = true;
} else {
if(ValidIONum(m_caster)) {
Entity * io = entities[m_caster];
target = io->pos;
beta = io->angle.getPitch();
displace = (io->ioflags & IO_NPC) == IO_NPC;
} else {
ARX_DEAD_CODE();
}
}
if(displace) {
target += angleToVectorXZ(beta) * 250.f;
}
m_pos = target + Vec3f(0, -10, 0);
DamageParameters damage;
damage.radius = 150.f;
damage.damages = 10.f;
damage.area = DAMAGE_FULL;
damage.duration = 100000000;
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_FIRE | DAMAGE_TYPE_FIELD;
damage.pos = target;
m_damage = DamageCreate(damage);
m_snd_loop = ARX_SOUND_PlaySFX(SND_SPELL_FIRE_FIELD_LOOP, &target, 1.f, ARX_SOUND_PLAY_LOOPED);
{
ParticleParams cp = ParticleParams();
cp.m_nbMax = 100;
cp.m_life = 2000;
cp.m_lifeRandom = 1000;
cp.m_pos = Vec3f(80, 10, 80);
cp.m_direction = Vec3f(0.f, 1.f, 0.f);
cp.m_angle = 0;
cp.m_speed = 0;
cp.m_speedRandom = 0;
cp.m_gravity = Vec3f_ZERO;
cp.m_flash = 0;
cp.m_rotation = 0;
cp.m_rotationRandomDirection = false;
cp.m_rotationRandomStart = false;
cp.m_startSegment.m_size = 10;
cp.m_startSegment.m_sizeRandom = 3;
cp.m_startSegment.m_color = Color(25, 25, 25, 50).to<float>();
cp.m_startSegment.m_colorRandom = Color(51, 51, 51, 101).to<float>();
cp.m_endSegment.m_size = 10;
cp.m_endSegment.m_sizeRandom = 3;
cp.m_endSegment.m_color = Color(25, 25, 25, 50).to<float>();
cp.m_endSegment.m_colorRandom = Color(0, 0, 0, 100).to<float>();
cp.m_texture.m_texLoop = true;
cp.m_blendMode = RenderMaterial::AlphaAdditive;
cp.m_freq = 150.0f;
cp.m_texture.set("graph/particles/firebase", 4, 100);
cp.m_spawnFlags = 0;
pPSStream.SetParams(cp);
}
pPSStream.SetPos(m_pos);
pPSStream.Update(0);
//-------------------------------------------------------------------------
{
ParticleParams cp = ParticleParams();
cp.m_nbMax = 50;
cp.m_life = 1000;
cp.m_lifeRandom = 500;
cp.m_pos = Vec3f(100, 10, 100);
cp.m_direction = Vec3f(0.f, -1.f, 0.f);
cp.m_angle = glm::radians(10.f);
cp.m_speed = 0;
cp.m_speedRandom = 0;
cp.m_gravity = Vec3f_ZERO;
cp.m_flash = 0;
cp.m_rotation = 0;
cp.m_rotationRandomDirection = false;
cp.m_rotationRandomStart = false;
cp.m_startSegment.m_size = 10;
cp.m_startSegment.m_sizeRandom = 10;
cp.m_startSegment.m_color = Color(40, 40, 40, 50).to<float>();
cp.m_startSegment.m_colorRandom = Color(51, 51, 51, 100).to<float>();
cp.m_endSegment.m_size = 10;
cp.m_endSegment.m_sizeRandom = 10;
cp.m_endSegment.m_color = Color(0, 0, 0, 50).to<float>();
cp.m_endSegment.m_colorRandom = Color(0, 0, 0, 100).to<float>();
cp.m_texture.m_texLoop = false;
cp.m_blendMode = RenderMaterial::Additive;
cp.m_freq = 150.0f;
cp.m_texture.set("graph/particles/fire", 0, 500);
cp.m_spawnFlags = 0;
pPSStream1.SetParams(cp);
}
pPSStream1.SetPos(m_pos + Vec3f(0, 10, 0));
pPSStream1.Update(0);
}
_X_EXPORT Bool
xf86CrtcRotate (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation)
{
ScrnInfoPtr pScrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
ScreenPtr pScreen = pScrn->pScreen;
PictTransform crtc_to_fb, fb_to_crtc;
PictureTransformIdentity (&crtc_to_fb);
PictureTransformIdentity (&fb_to_crtc);
PictureTransformIsInverse ("identity", &crtc_to_fb, &fb_to_crtc);
if (rotation != RR_Rotate_0)
{
xFixed rot_cos, rot_sin, rot_dx, rot_dy;
xFixed scale_x, scale_y, scale_dx, scale_dy;
int mode_w = crtc->mode.HDisplay;
int mode_h = crtc->mode.VDisplay;
/* rotation */
switch (rotation & 0xf) {
default:
case RR_Rotate_0:
rot_cos = F ( 1); rot_sin = F ( 0);
rot_dx = F ( 0); rot_dy = F ( 0);
break;
case RR_Rotate_90:
rot_cos = F ( 0); rot_sin = F ( 1);
rot_dx = F ( mode_h); rot_dy = F (0);
break;
case RR_Rotate_180:
rot_cos = F (-1); rot_sin = F ( 0);
rot_dx = F (mode_w); rot_dy = F ( mode_h);
break;
case RR_Rotate_270:
rot_cos = F ( 0); rot_sin = F (-1);
rot_dx = F ( 0); rot_dy = F ( mode_w);
break;
}
PictureTransformRotate (&crtc_to_fb, &fb_to_crtc, rot_cos, rot_sin);
PictureTransformIsInverse ("rotate", &crtc_to_fb, &fb_to_crtc);
PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, rot_dx, rot_dy);
PictureTransformIsInverse ("rotate translate", &crtc_to_fb, &fb_to_crtc);
/* reflection */
scale_x = F (1);
scale_dx = 0;
scale_y = F (1);
scale_dy = 0;
if (rotation & RR_Reflect_X)
{
scale_x = F(-1);
if (rotation & (RR_Rotate_0|RR_Rotate_180))
scale_dx = F(mode_w);
else
scale_dx = F(mode_h);
}
if (rotation & RR_Reflect_Y)
{
scale_y = F(-1);
if (rotation & (RR_Rotate_0|RR_Rotate_180))
scale_dy = F(mode_h);
else
scale_dy = F(mode_w);
}
PictureTransformScale (&crtc_to_fb, &fb_to_crtc, scale_x, scale_y);
PictureTransformIsInverse ("scale", &crtc_to_fb, &fb_to_crtc);
PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, scale_dx, scale_dy);
PictureTransformIsInverse ("scale translate", &crtc_to_fb, &fb_to_crtc);
}
/*
* If the untranslated transformation is the identity,
* disable the shadow buffer
*/
if (PictureTransformIsIdentity (&crtc_to_fb))
{
crtc->transform_in_use = FALSE;
PictureTransformInitTranslate (&crtc->crtc_to_framebuffer,
F (-crtc->x), F (-crtc->y));
PictureTransformInitTranslate (&crtc->framebuffer_to_crtc,
F ( crtc->x), F ( crtc->y));
xf86RotateDestroy (crtc);
}
else
{
PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, F(crtc->x), F(crtc->y));
PictureTransformIsInverse ("offset", &crtc_to_fb, &fb_to_crtc);
/*
* these are the size of the shadow pixmap, which
* matches the mode, not the pre-rotated copy in the
* frame buffer
*/
int width = mode->HDisplay;
int height = mode->VDisplay;
void *shadowData = crtc->rotatedData;
PixmapPtr shadow = crtc->rotatedPixmap;
int old_width = shadow ? shadow->drawable.width : 0;
int old_height = shadow ? shadow->drawable.height : 0;
/* Allocate memory for rotation */
if (old_width != width || old_height != height)
{
if (shadow || shadowData)
{
crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
shadowData = crtc->funcs->shadow_allocate (crtc, width, height);
if (!shadowData)
goto bail1;
crtc->rotatedData = shadowData;
/* shadow will be damaged in xf86RotatePrepare */
}
else
{
/* mark shadowed area as damaged so it will be repainted */
xf86CrtcDamageShadow (crtc);
}
if (!xf86_config->rotation_damage)
{
/* Create damage structure */
xf86_config->rotation_damage = DamageCreate (NULL, NULL,
DamageReportNone,
TRUE, pScreen, pScreen);
if (!xf86_config->rotation_damage)
goto bail2;
/* Wrap block handler */
xf86_config->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = xf86RotateBlockHandler;
}
if (0)
{
bail2:
if (shadow || shadowData)
{
crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
bail1:
if (old_width && old_height)
crtc->rotatedPixmap = crtc->funcs->shadow_create (crtc,
NULL,
old_width,
old_height);
return FALSE;
}
crtc->transform_in_use = TRUE;
crtc->crtc_to_framebuffer = crtc_to_fb;
crtc->framebuffer_to_crtc = fb_to_crtc;
crtc->bounds.x1 = 0;
crtc->bounds.x2 = crtc->mode.HDisplay;
crtc->bounds.y1 = 0;
crtc->bounds.y2 = crtc->mode.VDisplay;
PictureTransformBounds (&crtc->bounds, &crtc_to_fb);
}
/* All done */
return TRUE;
}
void CLightning::Render()
{
if(ulCurrentTime >= ulDuration)
return;
if(m_iTTL <= 0) {
fTotoro = 0;
fMySize = 2;
ReCreate(8);
}
Vec3f ePos;
float fBeta = 0.f;
float falpha = 0.f;
if(m_isMassLightning) {
ePos = Vec3f_ZERO;
} else {
ePos = m_pos;
fBeta = m_beta;
falpha = m_alpha;
}
float f = 1.5f * fMySize;
m_cnodetab[0].f = randomVec(-f, f);
RenderMaterial mat;
mat.setCulling(Renderer::CullNone);
mat.setDepthTest(false);
mat.setBlendType(RenderMaterial::Additive);
float fbeta = fBeta + rnd() * 2 * fMySize;
for(size_t i = 0; i < m_nbtotal && i <= fTotoro; i++) {
CLightningNode & node = m_cnodetab[i];
Vec3f astart = m_cnodetab[node.parent].pos + m_cnodetab[node.parent].f;
float temp = 1.5f * fMySize;
Vec3f z_z = m_cnodetab[node.parent].f + randomVec(-temp, temp);
float zz = node.size + node.size * 0.3f * rnd();
float xx = node.size * glm::cos(glm::radians(-fbeta));
node.f = z_z;
Vec3f a = node.pos + z_z;
if(!m_isMassLightning) {
Vec3f vv2;
Vec3f vv1 = astart;
vv1 = VRotateX(vv1, (falpha));
vv2 = VRotateY(vv1, 180 - MAKEANGLE(fBeta));
astart = vv2;
vv1 = a;
vv1 = VRotateX(vv1, (falpha));
vv2 = VRotateY(vv1, 180 - MAKEANGLE(fBeta));
a = vv2;
astart += ePos;
a += ePos;
}
if(i % 4 == 0) {
Sphere sphere;
sphere.origin = a;
sphere.radius = std::min(node.size, 50.f);
if(CheckAnythingInSphere(sphere, m_caster, CAS_NO_SAME_GROUP)) {
DamageParameters damage;
damage.pos = sphere.origin;
damage.radius = sphere.radius;
damage.damages = m_fDamage * m_level * ( 1.0f / 3 );
damage.area = DAMAGE_FULL;
damage.duration = 1;
damage.source = m_caster;
damage.flags = DAMAGE_FLAG_DONT_HURT_SOURCE | DAMAGE_FLAG_ADD_VISUAL_FX;
damage.type = DAMAGE_TYPE_FAKEFIRE | DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_LIGHTNING;
DamageCreate(damage);
}
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_ZERO;
q.v[2].uv = Vec2f_Y_AXIS;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart + Vec3f(0.f, zz, 0.f);
q.v[2].p = a + Vec3f(0.f, zz, 0.f);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_X_AXIS;
q.v[2].uv = Vec2f_ONE;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart - Vec3f(0.f, zz, 0.f);
q.v[2].p = a - Vec3f(0.f, zz, 0.f);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
zz *= glm::sin(glm::radians(fbeta));
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_X_AXIS;
q.v[2].uv = Vec2f_ONE;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart + Vec3f(xx, 0.f, zz);
q.v[2].p = a + Vec3f(xx, 0.f, zz);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
{
TexturedQuad q;
q.v[0].color = Color(255, 255, 255, 255).toRGBA();
q.v[1].color = Color(0, 0, 90, 255).toRGBA();
q.v[2].color = Color(0, 0, 90, 255).toRGBA();
q.v[3].color = Color(255, 255, 255, 255).toRGBA();
q.v[0].uv = Vec2f(0.5f, 0.f);
q.v[1].uv = Vec2f_ZERO;
q.v[2].uv = Vec2f_Y_AXIS;
q.v[3].uv = Vec2f(0.5f, 1.f);
q.v[0].p = astart;
q.v[1].p = astart - Vec3f(xx, 0.f, zz);
q.v[2].p = a - Vec3f(xx, 0.f, zz);
q.v[3].p = a;
drawQuadRTP(mat, q);
}
}
}
void IceFieldSpell::Launch() {
spells.endByCaster(m_caster, SPELL_ICE_FIELD);
ARX_SOUND_PlaySFX(g_snd.SPELL_ICE_FIELD);
m_duration = (m_launchDuration >= 0) ? m_launchDuration : GameDurationMs(100000);
m_hasDuration = true;
m_fManaCostPerSecond = 2.8f;
m_light = LightHandle();
Vec3f target;
float beta;
bool displace;
if(m_caster == EntityHandle_Player) {
target = player.basePosition();
beta = player.angle.getYaw();
displace = true;
} else {
Entity * io = entities.get(m_caster);
arx_assert(io);
target = io->pos;
beta = io->angle.getYaw();
displace = (io->ioflags & IO_NPC) == IO_NPC;
}
if(displace) {
target += angleToVectorXZ(beta) * 250.f;
}
m_pos = target;
DamageParameters damage;
damage.radius = 150.f;
damage.damages = 10.f;
damage.area = DAMAGE_FULL;
damage.duration = GameDurationMs(100000000);
damage.source = m_caster;
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_COLD | DAMAGE_TYPE_FIELD;
damage.pos = target;
m_damage = DamageCreate(damage);
tex_p1 = TextureContainer::Load("graph/obj3d/textures/(fx)_tsu_blueting");
tex_p2 = TextureContainer::Load("graph/obj3d/textures/(fx)_tsu_bluepouf");
for(int i = 0; i < iMax; i++) {
float t = Random::getf();
if(t < 0.5f) {
tType[i] = 0;
} else {
tType[i] = 1;
}
tSize[i] = Vec3f(0.f);
tSizeMax[i] = arx::randomVec3f() + Vec3f(0.f, 0.2f, 0.f);
Vec3f minPos = (tType[i] == 0) ? Vec3f(1.2f, 1.f, 1.2f) : Vec3f(0.4f, 0.3f, 0.4f);
tSizeMax[i] = glm::max(tSizeMax[i], minPos);
if(tType[i] == 0) {
tPos[i].x = m_pos.x + Random::getf(-80.f, 80.f);
tPos[i].y = m_pos.y;
tPos[i].z = m_pos.z + Random::getf(-80.f, 80.f);
} else {
tPos[i].x = m_pos.x + Random::getf(-120.f, 120.f);
tPos[i].y = m_pos.y;
tPos[i].z = m_pos.z + Random::getf(-120.f, 120.f);
}
}
m_snd_loop = ARX_SOUND_PlaySFX_loop(g_snd.SPELL_ICE_FIELD_LOOP, &target, 1.f);
}
void MagicMissileSpell::Update() {
for(size_t i = 0; i < pTab.size(); i++) {
CMagicMissile * missile = pTab[i];
if(missile->bExplo)
continue;
Sphere sphere = Sphere(missile->eCurPos, 10.f);
if(CheckAnythingInSphere(sphere, m_caster, CAS_NO_SAME_GROUP)) {
LaunchMagicMissileExplosion(missile->eCurPos, m_mrCheat);
ARX_NPC_SpawnAudibleSound(missile->eCurPos, entities[m_caster]);
missile->SetTTL(ArxDurationMs(1000));
missile->bExplo = true;
missile->bMove = false;
missile->lLightId = LightHandle();
DamageParameters damage;
damage.pos = missile->eCurPos;
damage.radius = 80.f;
damage.damages = (4 + m_level * ( 1.0f / 5 )) * .8f;
damage.area = DAMAGE_FULL;
damage.duration = ArxDuration(-1);
damage.source = m_caster;
damage.flags = DAMAGE_FLAG_DONT_HURT_SOURCE;
damage.type = DAMAGE_TYPE_MAGICAL;
DamageCreate(damage);
Color3f rgb(.3f, .3f, .45f);
ARX_PARTICLES_Add_Smoke(missile->eCurPos, 0, 6, rgb);
}
}
for(size_t i = 0 ; i < pTab.size() ; i++) {
pTab[i]->Update(ArxDurationMs(g_framedelay));
}
{ // CheckAllDestroyed
long nbmissiles = 0;
for(size_t i = 0; i < pTab.size(); i++) {
CMagicMissile *pMM = pTab[i];
if(pMM->bMove)
nbmissiles++;
}
if(nbmissiles == 0)
m_duration = ArxDuration_ZERO;
}
for(size_t i = 0; i < pTab.size(); i++) {
pTab[i]->Render();
CMagicMissile * pMM = pTab[i];
EERIE_LIGHT * el = lightHandleGet(pMM->lLightId);
if(el) {
el->intensity = 0.7f + 2.3f * pMM->lightIntensityFactor;
el->pos = pMM->eCurPos;
el->creationTime = arxtime.now();
}
}
}
// Draws Flame Particles
void TreatBackgroundActions() {
ARX_PROFILE_FUNC();
float fZFar = square(ACTIVECAM->cdepth * fZFogEnd * 1.3f);
for(size_t i = 0; i < g_staticLightsMax; i++) {
EERIE_LIGHT * gl = g_staticLights[i];
if(!gl) {
continue;
}
float dist = arx::distance2(gl->pos, ACTIVECAM->orgTrans.pos);
if(dist > fZFar) {
// Out of treat range
ARX_SOUND_Stop(gl->sample);
gl->sample = audio::INVALID_ID;
continue;
}
if((gl->extras & EXTRAS_SPAWNFIRE) && gl->m_ignitionStatus) {
DamageParameters damage;
damage.radius = gl->ex_radius;
damage.damages = gl->ex_radius * (1.0f / 7);
damage.area = DAMAGE_FULL;
damage.duration = ArxDurationMs(1);
damage.source = EntityHandle();
damage.flags = 0;
damage.type = DAMAGE_TYPE_MAGICAL | DAMAGE_TYPE_FIRE | DAMAGE_TYPE_NO_FIX;
damage.pos = gl->pos;
DamageCreate(damage);
}
if(!(gl->extras & (EXTRAS_SPAWNFIRE | EXTRAS_SPAWNSMOKE)) || !gl->m_ignitionStatus) {
if(!gl->m_ignitionStatus && gl->sample != audio::INVALID_ID) {
ARX_SOUND_Stop(gl->sample);
gl->sample = audio::INVALID_ID;
}
continue;
}
if(gl->sample == audio::INVALID_ID) {
gl->sample = SND_FIREPLACE;
ARX_SOUND_PlaySFX(gl->sample, &gl->pos, Random::getf(0.95f, 1.05f), ARX_SOUND_PLAY_LOOPED);
} else {
ARX_SOUND_RefreshPosition(gl->sample, gl->pos);
}
float amount = 2.f;
if(dist < square(ACTIVECAM->cdepth * (1.f / 6))) {
amount = 3.f;
} else if(dist < square(ACTIVECAM->cdepth * (1.f / 3))) {
amount = 2.5f;
}
const float targetFPS = 61.f;
const float targetDelay = 1000.f / targetFPS;
long count = gl->m_storedFlameTime.update(amount * g_framedelay * (1.f / targetDelay));
for(long n = 0; n < count; n++) {
if(Random::getf() < gl->ex_frequency) {
PARTICLE_DEF * pd = createParticle();
if(pd) {
float t = Random::getf() * glm::pi<float>();
Vec3f s = Vec3f(std::sin(t), std::sin(t), std::cos(t)) * randomVec();
pd->ov = gl->pos + s * gl->ex_radius;
pd->move = Vec3f(2.f, 2.f, 2.f) - Vec3f(4.f, 22.f, 4.f) * randomVec3f();
pd->move *= gl->ex_speed;
pd->siz = 7.f * gl->ex_size;
pd->tolive = 500 + Random::getu(0, 1000 * gl->ex_speed);
if((gl->extras & EXTRAS_SPAWNFIRE) && (gl->extras & EXTRAS_SPAWNSMOKE)) {
pd->m_flags = FIRE_TO_SMOKE;
}
pd->tc = (gl->extras & EXTRAS_SPAWNFIRE) ? fire2 : smokeparticle;
pd->m_flags |= ROTATING;
pd->m_rotation = 0.1f - Random::getf(0.f, 0.2f) * gl->ex_speed;
pd->scale = Vec3f(-8.f);
pd->rgb = (gl->extras & EXTRAS_COLORLEGACY) ? gl->rgb : Color3f::white;
}
}
if(!(gl->extras & EXTRAS_SPAWNFIRE) || Random::getf() <= 0.95f) {
continue;
}
if(Random::getf() < gl->ex_frequency) {
PARTICLE_DEF * pd = createParticle();
if(pd) {
float t = Random::getf() * (glm::pi<float>() * 2.f) - glm::pi<float>();
Vec3f s = Vec3f(std::sin(t), std::sin(t), std::cos(t)) * randomVec();
pd->ov = gl->pos + s * gl->ex_radius;
Vec3f vect = glm::normalize(pd->ov - gl->pos);
float d = (gl->extras & EXTRAS_FIREPLACE) ? 6.f : 4.f;
pd->move = Vec3f(vect.x * d, Random::getf(-18.f, -10.f), vect.z * d) * gl->ex_speed;
pd->siz = 4.f * gl->ex_size * 0.3f;
pd->tolive = 1200 + Random::getu(0, 500 * gl->ex_speed);
pd->tc = fire2;
pd->m_flags |= ROTATING | GRAVITY;
pd->m_rotation = 0.1f - Random::getf(0.f, 0.2f) * gl->ex_speed;
pd->scale = Vec3f(-3.f);
pd->rgb = (gl->extras & EXTRAS_COLORLEGACY) ? gl->rgb : Color3f::white;
}
}
}
}
}
static Bool
CreateScreenResources(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
PixmapPtr rootPixmap;
Bool ret;
void *pixels = NULL;
int err;
pScreen->CreateScreenResources = ms->createScreenResources;
ret = pScreen->CreateScreenResources(pScreen);
pScreen->CreateScreenResources = CreateScreenResources;
if (!drmmode_set_desired_modes(pScrn, &ms->drmmode))
return FALSE;
if (!drmmode_glamor_handle_new_screen_pixmap(&ms->drmmode))
return FALSE;
drmmode_uevent_init(pScrn, &ms->drmmode);
if (!ms->drmmode.sw_cursor)
drmmode_map_cursor_bos(pScrn, &ms->drmmode);
if (!ms->drmmode.gbm) {
pixels = drmmode_map_front_bo(&ms->drmmode);
if (!pixels)
return FALSE;
}
rootPixmap = pScreen->GetScreenPixmap(pScreen);
if (ms->drmmode.shadow_enable)
pixels = ms->drmmode.shadow_fb;
if (!pScreen->ModifyPixmapHeader(rootPixmap, -1, -1, -1, -1, -1, pixels))
FatalError("Couldn't adjust screen pixmap\n");
if (ms->drmmode.shadow_enable) {
if (!shadowAdd(pScreen, rootPixmap, msUpdatePacked,
msShadowWindow, 0, 0))
return FALSE;
}
err = drmModeDirtyFB(ms->fd, ms->drmmode.fb_id, NULL, 0);
if (err != -EINVAL && err != -ENOSYS) {
ms->damage = DamageCreate(NULL, NULL, DamageReportNone, TRUE,
pScreen, rootPixmap);
if (ms->damage) {
DamageRegister(&rootPixmap->drawable, ms->damage);
ms->dirty_enabled = TRUE;
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Damage tracking initialized\n");
}
else {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Failed to create screen damage record\n");
return FALSE;
}
}
return ret;
}
/* With mixed pixmaps, if we fail to get direct access to the driver pixmap, we
* use the DownloadFromScreen hook to retrieve contents to a copy in system
* memory, perform software rendering on that and move back the results with the
* UploadToScreen hook (see exaDamageReport_mixed).
*/
void
exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
{
ExaPixmapPriv(pPixmap);
Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
Bool success;
success = ExaDoPrepareAccess(pPixmap, index);
if (success && has_gpu_copy && pExaPixmap->pDamage) {
/* You cannot do accelerated operations while a buffer is mapped. */
exaFinishAccess(&pPixmap->drawable, index);
/* Update the gpu view of both deferred destination pixmaps and of
* source pixmaps that were migrated with a bounding region.
*/
exaMoveInPixmap_mixed(pPixmap);
success = ExaDoPrepareAccess(pPixmap, index);
if (success) {
/* We have a gpu pixmap that can be accessed, we don't need the cpu
* copy anymore. Drivers that prefer DFS, should fail prepare
* access.
*/
DamageDestroy(pExaPixmap->pDamage);
pExaPixmap->pDamage = NULL;
free(pExaPixmap->sys_ptr);
pExaPixmap->sys_ptr = NULL;
return;
}
}
if (!success) {
ExaMigrationRec pixmaps[1];
/* Do we need to allocate our system buffer? */
if (!pExaPixmap->sys_ptr) {
pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch *
pPixmap->drawable.height);
if (!pExaPixmap->sys_ptr)
FatalError("EXA: malloc failed for size %d bytes\n",
pExaPixmap->sys_pitch * pPixmap->drawable.height);
}
if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
}
else {
pixmaps[0].as_dst = FALSE;
pixmaps[0].as_src = TRUE;
}
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = pReg;
if (!pExaPixmap->pDamage &&
(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {
Bool as_dst = pixmaps[0].as_dst;
/* Set up damage tracking */
pExaPixmap->pDamage = DamageCreate(exaDamageReport_mixed, NULL,
DamageReportNonEmpty, TRUE,
pPixmap->drawable.pScreen,
pPixmap);
if (pExaPixmap->pDamage) {
DamageRegister(&pPixmap->drawable, pExaPixmap->pDamage);
/* This ensures that pending damage reflects the current
* operation. This is used by exa to optimize migration.
*/
DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
}
if (has_gpu_copy) {
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
pPixmap->drawable.height);
/* We don't know which region of the destination will be damaged,
* have to assume all of it
*/
if (as_dst) {
pixmaps[0].as_dst = FALSE;
pixmaps[0].as_src = TRUE;
pixmaps[0].pReg = NULL;
}
exaCopyDirtyToSys(pixmaps);
}
if (as_dst)
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
pPixmap->drawable.height);
}
else if (has_gpu_copy)
exaCopyDirtyToSys(pixmaps);
pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
pPixmap->devKind = pExaPixmap->sys_pitch;
pExaPixmap->use_gpu_copy = FALSE;
}
}
