void BorderImage_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
{
me.isNexposeeTitleBar = 0;
if(me.zoomedOutTitleBar)
if(me.parent.parent.instanceOfNexposee)
if(me.parent.instanceOfDialog)
if(me == me.parent.frame)
me.isNexposeeTitleBar = 1;
if(me.isNexposeeTitleBar)
{
vector scrs;
scrs = eX * conwidth + eY * conheight;
SUPER(BorderImage).resizeNotify(me, relOrigin, relSize, boxToGlobal(me.parent.Nexposee_smallOrigin, '0 0 0', scrs), boxToGlobalSize(me.parent.Nexposee_smallSize, scrs));
me.realOrigin_y = me.realFontSize_y * me.zoomedOutTitleBarPosition;
me.realOrigin_Nexposeed = me.realOrigin;
me.realFontSize_Nexposeed = me.realFontSize;
}
SUPER(BorderImage).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
me.borderVec_x = me.borderHeight / absSize_x;
me.borderVec_y = me.borderHeight / absSize_y;
me.realOrigin_y = 0.5 * (me.borderVec_y - me.realFontSize_y);
if(me.closeButton)
{
// move the close button to the right place
me.closeButton.Container_origin = '1 0 0' * (1 - me.borderVec_x);
me.closeButton.Container_size = me.borderVec;
me.closeButton.color = me.color;
me.closeButton.colorC = me.color;
me.closeButton.colorF = me.color;
}
}
spAttachment* _spAtlasAttachmentLoader_newAttachment (spAttachmentLoader* loader, spSkin* skin, spAttachmentType type,
const char* name) {
spAtlasAttachmentLoader* self = SUB_CAST(spAtlasAttachmentLoader, loader);
switch (type) {
case ATTACHMENT_REGION: {
spRegionAttachment* attachment;
spAtlasRegion* region = spAtlas_findRegion(self->atlas, name);
if (!region) {
_spAttachmentLoader_setError(loader, "Region not found: ", name);
return 0;
}
attachment = spRegionAttachment_create(name);
attachment->rendererObject = region;
spRegionAttachment_setUVs(attachment, region->u, region->v, region->u2, region->v2, region->rotate);
attachment->regionOffsetX = region->offsetX;
attachment->regionOffsetY = region->offsetY;
attachment->regionWidth = region->width;
attachment->regionHeight = region->height;
attachment->regionOriginalWidth = region->originalWidth;
attachment->regionOriginalHeight = region->originalHeight;
return SUPER(attachment);
}
case ATTACHMENT_BOUNDING_BOX:
return SUPER(spBoundingBoxAttachment_create(name));
default:
_spAttachmentLoader_setUnknownTypeError(loader, type);
return 0;
}
}
Skeleton* _Cocos2dxSkeleton_create (SkeletonData* data, CCSkeleton* node) {
Cocos2dxSkeleton* self = NEW(Cocos2dxSkeleton);
_Skeleton_init(SUPER(self), data);
VTABLE(Skeleton, self) ->dispose = _Cocos2dxSkeleton_dispose;
self->node = node;
return SUPER(self);
}
spMeshAttachment* spMeshAttachment_create (const char* name) {
spMeshAttachment* self = NEW(spMeshAttachment);
self->r = 1;
self->g = 1;
self->b = 1;
self->a = 1;
_spAttachment_init(SUPER(SUPER(self)), name, SP_ATTACHMENT_MESH, _spMeshAttachment_dispose);
return self;
}
AtlasPage* AtlasPage_create (const char* name) {
Cocos2dxAtlasPage* self = NEW(Cocos2dxAtlasPage);
_AtlasPage_init(SUPER(self), name);
VTABLE(AtlasPage, self) ->dispose = _Cocos2dxAtlasPage_dispose;
self->texture = CCTextureCache::sharedTextureCache()->addImage(name);
self->texture->retain();
self->atlas = CCTextureAtlas::createWithTexture(self->texture, 4);
self->atlas->retain();
return SUPER(self);
}
void XonoticPlayerModelSelector_draw(entity me)
{
float i, n;
vector o;
if (me.numModels <= 0)
{
draw_CenterText('0.5 0.5 0', _("<no model found>"), me.realFontSize, '1 1 1', 0.6, FALSE);
return;
}
SUPER(XonoticPlayerModelSelector).draw(me);
// draw text on the image, handle \n in the description
draw_beginBoldFont();
draw_CenterText('0.5 0 0', me.currentModelTitle, me.realFontSize * (me.titleFontSize / me.fontSize), SKINCOLOR_MODELTITLE, SKINALPHA_MODELTITLE, FALSE);
draw_endBoldFont();
o = '0.5 1 0' - eY * me.realFontSize_y * ((n = tokenizebyseparator(me.currentModelDescription, "\n")) + 0.5);
for(i = 0; i < n; ++i)
{
draw_CenterText(o, argv(i), me.realFontSize, '1 1 1', 1, FALSE);
o += eY * me.realFontSize_y;
}
}
spRegionAttachment* spRegionAttachment_create (const char* name) {
spRegionAttachment* self = NEW(spRegionAttachment);
self->scaleX = 1;
self->scaleY = 1;
_spAttachment_init(SUPER(self), name, ATTACHMENT_REGION, _spRegionAttachment_dispose);
return self;
}
void XonoticCrosshairButton_draw(entity me)
{
vector sz, rgb;
float a;
rgb = eX * cvar("crosshair_color_red") + eY * cvar("crosshair_color_green") + eZ * cvar("crosshair_color_blue");
a = cvar("crosshair_alpha");
if(!me.checked && !me.focused)
{
a *= me.disabledAlpha;
rgb = '1 1 1';
}
SUPER(XonoticCrosshairButton).draw(me);
sz = draw_PictureSize(me.src3);
sz = globalToBoxSize(sz, draw_scale);
sz = (10 * '1 1 0' + sz * cvar("crosshair_size")) * 0.05; // (10 * '1 1 0' + ...) * 0.05 here to make visible size changes happen also at bigger sizes
if(sz_x > 0.95)
sz = sz * (0.95 / sz_x);
if(sz_y > 0.95)
sz = sz * (0.95 / sz_y);
draw_Picture('0.5 0.5 0' - 0.5 * sz, me.src3, sz, rgb, a);
if(cvar("crosshair_dot"))
draw_Picture('0.5 0.5 0' - 0.5 * sz * cvar("crosshair_dot_size"), me.src4, sz * cvar("crosshair_dot_size"), rgb, a * cvar("crosshair_dot_alpha"));
}
void BorderImage_draw(entity me)
{
//print(vtos(me.borderVec), "\n");
if(me.src)
draw_BorderPicture('0 0 0', me.src, '1 1 0', me.color, 1, me.borderVec);
if(me.fontSize > 0)
{
vector ro, rf, df;
if(me.isNexposeeTitleBar)
{
// me.parent.Nexposee_animationFactor 0 (small) or 1 (full)
// default values are for 1
ro = me.realOrigin;
rf = me.realFontSize;
df = draw_fontscale;
me.realOrigin = ro * me.parent.Nexposee_animationFactor + me.realOrigin_Nexposeed * (1 - me.parent.Nexposee_animationFactor);
me.realFontSize = rf * me.parent.Nexposee_animationFactor + me.realFontSize_Nexposeed * (1 - me.parent.Nexposee_animationFactor);
draw_fontscale = globalToBoxSize(boxToGlobalSize(df, me.realFontSize), rf);
}
SUPER(BorderImage).draw(me);
if(me.isNexposeeTitleBar)
{
// me.Nexposee_animationState 0 (small) or 1 (full)
// default values are for 1
me.realOrigin = ro;
me.realFontSize = rf;
draw_fontscale = df;
}
}
};
/**
* Initialize a VMClass
*/
void _VMClass_init(void* _self, ...) {
pVMClass self = (pVMClass)_self;
va_list args;
va_start(args, _self);
SUPER(VMObject, self, init, va_arg(args, intptr_t));
va_end(args);
}
spSlot* spSlot_create (spSlotData* data, spBone* bone) {
spSlot* self = SUPER(NEW(_spSlot));
CONST_CAST(spSlotData*, self->data) = data;
CONST_CAST(spBone*, self->bone) = bone;
spSlot_setToSetupPose(self);
return self;
}
void XonoticSliderCheckBox_draw(entity me)
{
me.checked = ((me.controlledSlider.value == me.offValue) != me.inverted);
if(me.controlledSlider.value == median(me.controlledSlider.valueMin, me.controlledSlider.value, me.controlledSlider.valueMax))
me.savedValue = me.controlledSlider.value;
SUPER(XonoticSliderCheckBox).draw(me);
}
RegionAttachment* RegionAttachment_create (const char* name) {
RegionAttachment* self = NEW(RegionAttachment);
self->scaleX = 1;
self->scaleY = 1;
_Attachment_init(SUPER(self), name, ATTACHMENT_REGION, _Attachment_deinit);
return self;
}
spSkeleton* spSkeleton_create (spSkeletonData* data) {
int i, ii;
_spSkeleton* internal = NEW(_spSkeleton);
spSkeleton* self = SUPER(internal);
CONST_CAST(spSkeletonData*, self->data) = data;
self->bonesCount = self->data->bonesCount;
self->bones = MALLOC(spBone*, self->bonesCount);
for (i = 0; i < self->bonesCount; ++i) {
spBoneData* boneData = self->data->bones[i];
spBone* parent = 0;
if (boneData->parent) {
/* Find parent bone. */
for (ii = 0; ii < self->bonesCount; ++ii) {
if (data->bones[ii] == boneData->parent) {
parent = self->bones[ii];
break;
}
}
}
self->bones[i] = spBone_create(boneData, self, parent);
}
CONST_CAST(spBone*, self->root) = self->bones[0];
self->slotsCount = data->slotsCount;
self->slots = MALLOC(spSlot*, self->slotsCount);
for (i = 0; i < self->slotsCount; ++i) {
spSlotData *slotData = data->slots[i];
/* Find bone for the slotData's boneData. */
spBone* bone = 0;
for (ii = 0; ii < self->bonesCount; ++ii) {
if (data->bones[ii] == slotData->boneData) {
bone = self->bones[ii];
break;
}
}
self->slots[i] = spSlot_create(slotData, bone);
}
self->drawOrder = MALLOC(spSlot*, self->slotsCount);
memcpy(self->drawOrder, self->slots, sizeof(spSlot*) * self->slotsCount);
self->r = 1;
self->g = 1;
self->b = 1;
self->a = 1;
self->ikConstraintsCount = data->ikConstraintsCount;
self->ikConstraints = MALLOC(spIkConstraint*, self->ikConstraintsCount);
for (i = 0; i < self->data->ikConstraintsCount; ++i)
self->ikConstraints[i] = spIkConstraint_create(self->data->ikConstraints[i], self);
spSkeleton_updateCache(self);
return self;
}
void _VMArray_mark_references(void* _self) {
pVMArray self = (pVMArray)_self;
int size_of_indexable_fields = SEND(self, get_number_of_indexable_fields);
for(int i=0;i<size_of_indexable_fields;i++) {
gc_mark_object(SEND(self, get_indexable_field, i));
}
SUPER(VMObject, self, mark_references);
}
void NexuizCreditsList_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
{
SUPER(NexuizCreditsList).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
me.realFontSize_y = me.fontSize / (absSize_y * me.itemHeight);
me.realFontSize_x = me.fontSize / (absSize_x * (1 - me.controlWidth));
me.realUpperMargin = 0.5 * (1 - me.realFontSize_y);
}
void Button_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
{
if(me.srcMulti)
me.keepspaceLeft = 0;
else
me.keepspaceLeft = min(0.8, absSize_y / absSize_x);
SUPER(Button).resizeNotify(me, relOrigin, relSize, absOrigin, absSize);
}
string XonoticDecibelsSlider_valueToText(entity me, float v)
{
if(v < -33)
return "OFF";
else if(v >= -0.1)
return "MAX";
return strcat(SUPER(XonoticDecibelsSlider).valueToText(me, v), " dB");
}
void _spPathAttachment_dispose (spAttachment* attachment) {
spPathAttachment* self = SUB_CAST(spPathAttachment, attachment);
_spVertexAttachment_deinit(SUPER(self));
FREE(self->lengths);
FREE(self);
}
void NexuizPlayerSettingsTab_draw(entity me)
{
if(cvar_string("_cl_name") == "Player")
me.playerNameLabel.alpha = ((mod(time * 2, 2) < 1) ? 1 : 0);
else
me.playerNameLabel.alpha = me.playerNameLabelAlpha;
SUPER(NexuizPlayerSettingsTab).draw(me);
}
void NexuizSlider_setValue(entity me, float val)
{
if(val != me.value)
{
SUPER(NexuizSlider).setValue( me, val );
me.saveCvars(me);
}
}
Slot* Slot_create (SlotData* data, Skeleton* skeleton, Bone* bone) {
Slot* self = SUPER(NEW(_Slot));
CONST_CAST(SlotData*, self->data) = data;
CONST_CAST(Skeleton*, self->skeleton) = skeleton;
CONST_CAST(Bone*, self->bone) = bone;
Slot_setToSetupPose(self);
return self;
}
/**
*
* Initialize a VMBigInteger
*
*/
void _VMBigInteger_init(void* _self, ...) {
pVMBigInteger self = (pVMBigInteger)_self;
SUPER(VMObject, self, init, 0);
va_list args; va_start(args, _self);
self->embedded_biginteger = va_arg(args, int64_t);
va_end(args);
}
float XonoticWeaponsList_mouseDrag(entity me, vector pos)
{
float f, i;
i = me.selectedItem;
f = SUPER(XonoticWeaponsList).mouseDrag(me, pos);
if(me.selectedItem != i)
cvar_set("cl_weaponpriority", swapInPriorityList(cvar_string("cl_weaponpriority"), me.selectedItem, i));
return f;
}
float NexuizDemoList_keyDown(entity me, float scan, float ascii, float shift)
{
if(scan == K_ENTER || scan == K_KP_ENTER) {
me.startDemo(me);
return 1;
}
else
return SUPER(NexuizDemoList).keyDown(me, scan, ascii, shift);
}
/**
* Initialize a VMInteger
*/
void _VMInteger_init(void* _self, ...) {
pVMInteger self = (pVMInteger)_self;
SUPER(VMObject, self, init, (intptr_t) 0);
va_list args; va_start(args, _self);
self->embedded_integer = va_arg(args, int64_t);
self->hash = self->embedded_integer;
va_end(args);
}
void _Cocos2dxAtlasPage_dispose (AtlasPage* page) {
Cocos2dxAtlasPage* self = SUB_CAST(Cocos2dxAtlasPage, page);
_AtlasPage_deinit(SUPER(self));
CC_SAFE_RELEASE_NULL(self->texture);
CC_SAFE_RELEASE_NULL(self->atlas);
FREE(page);
}
/**
*
* Initialize a VMArray
*
*/
void _VMArray_init(void* _self, ...) {
pVMArray self = (pVMArray)_self;
va_list args;
va_start(args, _self);
size_t fields = SEND(self, _get_offset) + va_arg(args, size_t);
va_end(args);
SUPER(VMObject, _self, init, fields);
}
void _HashmapElem_init(void* _self, ...) {
pHashmapElem self = (pHashmapElem)_self;
SUPER(OOObject, self, init);
va_list argp;
va_start(argp, _self);
self->key = va_arg(argp, void*);
self->value = va_arg(argp, void*);
va_end(argp);
}
void _Cocos2dxRegionAttachment_draw (Attachment* attachment, Slot* slot) {
Cocos2dxRegionAttachment* self = SUB_CAST(Cocos2dxRegionAttachment, attachment);
Cocos2dxSkeleton* skeleton = SUB_CAST(Cocos2dxSkeleton, slot->skeleton);
GLubyte r = SUPER(skeleton)->r * slot->r * 255;
GLubyte g = SUPER(skeleton)->g * slot->g * 255;
GLubyte b = SUPER(skeleton)->b * slot->b * 255;
GLubyte a = SUPER(skeleton)->a * slot->a * 255;
ccV3F_C4B_T2F_Quad* quad = &self->quad;
quad->bl.colors.r = r;
quad->bl.colors.g = g;
quad->bl.colors.b = b;
quad->bl.colors.a = a;
quad->tl.colors.r = r;
quad->tl.colors.g = g;
quad->tl.colors.b = b;
quad->tl.colors.a = a;
quad->tr.colors.r = r;
quad->tr.colors.g = g;
quad->tr.colors.b = b;
quad->tr.colors.a = a;
quad->br.colors.r = r;
quad->br.colors.g = g;
quad->br.colors.b = b;
quad->br.colors.a = a;
float* offset = SUPER(self)->offset;
quad->bl.vertices.x = offset[0] * slot->bone->m00 + offset[1] * slot->bone->m01 + slot->bone->worldX;
quad->bl.vertices.y = offset[0] * slot->bone->m10 + offset[1] * slot->bone->m11 + slot->bone->worldY;
quad->tl.vertices.x = offset[2] * slot->bone->m00 + offset[3] * slot->bone->m01 + slot->bone->worldX;
quad->tl.vertices.y = offset[2] * slot->bone->m10 + offset[3] * slot->bone->m11 + slot->bone->worldY;
quad->tr.vertices.x = offset[4] * slot->bone->m00 + offset[5] * slot->bone->m01 + slot->bone->worldX;
quad->tr.vertices.y = offset[4] * slot->bone->m10 + offset[5] * slot->bone->m11 + slot->bone->worldY;
quad->br.vertices.x = offset[6] * slot->bone->m00 + offset[7] * slot->bone->m01 + slot->bone->worldX;
quad->br.vertices.y = offset[6] * slot->bone->m10 + offset[7] * slot->bone->m11 + slot->bone->worldY;
// cocos2dx doesn't handle batching for us, so we'll just force a single texture per skeleton.
skeleton->node->atlas = self->atlas;
if (self->atlas->getCapacity() <= skeleton->node->quadCount) {
if (!self->atlas->resizeCapacity(self->atlas->getCapacity() * 2)) return;
}
self->atlas->updateQuad(quad, skeleton->node->quadCount++);
}
