void ClientApp::mouseDown( MouseEvent event )
{
// fake "buttons" to trigger events
if( infoRect.contains( event.getPos() ) )
{
LOG( "testing info logging" );
}
if( warnRect.contains( event.getPos() ) )
{
LOG_WARN( "testing warn logging" );
}
if( errorRect.contains( event.getPos() ) )
{
LOG_ERR( "testing error logging" );
}
if( eventRect.contains( event.getPos() ) )
{
AMPMClient::get()->sendEvent( "category", "action", "label", 10 );
}
if( crashRect.contains( event.getPos() ) )
{
quit();
}
}
void TextParticlesApp::mouseDrag( MouseEvent event )
{
Rectf r = Rectf( 0, 0, getWindowWidth(), getWindowHeight() );
if ( r.contains( event.getPos() )) {
mCamUi.mouseDrag( event );
}
}
bool Control::isHit( const glm::vec2 &pt )
{
if( mVisible )
{
Rectf r = mHitRect;
r.offset( getOrigin() );
return r.contains( pt );
}
return false;
}
void mouseDrag( MouseEvent event )
{
if (mEditMode == EditMode_RECORD) return;
// 制御点の選択を行う
if (event.isLeftDown()) {
if (mSelectionMode == 0) return;
float x1 = mSelectRegion.getX1();
float y1 = mSelectRegion.getY1();
mSelectRegion.set(x1, y1, event.getX()+5, event.getY()+5);
for (int k = 0; k < mCtrlPointsNum; ++k) {
if (mSelectRegion.contains(mCtrlPoints[k].pos)) {
mCtrlPoints[k].isSelected = true;
} else {
mCtrlPoints[k].isSelected = false;
}
}
}
Vec2f d = event.getPos() - mMPPrev;
if (event.isRightDown()) {
for (int k = 0; k < mCtrlPointsNum; ++k) {
if (mCtrlPoints[k].isSelected) {
mCtrlPoints[k].mag += d;
}
}
}
if (event.isMiddleDown()) {
int ci = -1;
int cj = -1;
float nearest = 1.e+10;
for (int j = 0; j < 2; ++j) {
for (int i = 0; i < 2; ++i) {
Vec2f cp(distpoints[j][i][0], distpoints[j][i][1]);
float dist = event.getPos().distance(cp);
if (dist < nearest) {
ci = i;
cj = j;
nearest = dist;
}
}
}
if (ci > -1 && cj > -1) {
distpoints[cj][ci][0] += d.x;
distpoints[cj][ci][1] += d.y;
}
}
mMPPrev = event.getPos();
}
bool View::isHit( const vec2 &pt )
{
if( mVisible )
{
Rectf r;
r.set( 0, 0, getWidth(), getHeight() );
r.offset( getOrigin() );
return r.contains( pt );
}
return false;
}
bool TouchableLink::hitTest(const Vec2f &point, float *distance)
{
Rectf extra = bounds.inflated(Vec2f(hitExtra, hitExtra));
if (extra.contains(point))
{
*distance = bounds.distance(point);
return true;
}
return false;
}
bool
Sector::inside(const Rectf& rect) const
{
for(auto& solids : solid_tilemaps) {
Rectf bbox = solids->get_bbox();
bbox.p1.y = -INFINITY; // pretend the tilemap extends infinitely far upwards
if (bbox.contains(rect))
return true;
}
return false;
}
bool
Sector::inside(const Rectf& rect) const
{
for(auto i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
TileMap* solids = *i;
Rectf bbox = solids->get_bbox();
bbox.p1.y = -INFINITY; // pretend the tilemap extends infinitely far upwards
if (bbox.contains(rect))
return true;
}
return false;
}
size_t ScanlinePacker::pushRect( Rectf rect )
{ // TODO: better error handling
assert( rect.getWidth() < mConstraints.x );
if( rect.getUpperLeft() != vec2( 0 ) )
{
rect -= rect.getUpperLeft();
}
vec2 loc( mPadding );
bool placed = false;
while( !placed )
{
for( const Rectf &r : mRectangles )
{
Rectf bounds = r.inflated( mPadding );
if( bounds.contains( loc ) )
{ // move to the outside edge of bounds
loc.x = bounds.getX2();
}
}
if( loc.x + rect.getWidth() < mConstraints.x - mPadding.x )
{ // probably placed, let's check our boundaries
placed = true;
Rectf potentialBounds = (rect + loc).inflated( vec2( -1.0f, -1.0f ) );
for( const Rectf &r : mRectangles )
{
Rectf bounds = r.inflated( mPadding );
if( potentialBounds.intersects( bounds ) )
{
placed = false;
}
}
}
if( !placed )
{ // move to next row for continued evaluation
loc.x = mPadding.x;
loc.y += mPadding.y; // could vary this step to optimize for grid
}
else
{
rect += loc;
mRectangles.push_back( rect );
}
}
return mRectangles.size() - 1;
}
void Island::handleCollision( const Gear *gear, const Vec2f &contactPoint )
{
mAudio->getNextAltoSynth()->trigger( mFreqMidi, 1.4f );
float pointsPerMeter = SceneController::getPointsPerMeter();
for( size_t i = 0; i < mBumpers.size(); i++ ) {
Vec2f centerPos = box2d::toCinder( mBody->GetPosition() ) * pointsPerMeter;
Rectf bbox = mBumperBoundingBoxes[i] + centerPos;
if( bbox.contains( contactPoint ) ) {
auto &bumperAnim = mBumperVibrationLevels[i];
bumperAnim.stop();
bumperAnim = 1.0f;
app::timeline().apply( &bumperAnim, 0.0f, 1.0f );
}
}
mVibrationLevel.stop();
mVibrationLevel = 0.4f;
app::timeline().apply( &mVibrationLevel, 0.0f, 1.4f, EaseOutQuart() );
}
void Bullet::update(
void
)
{
Rectf boundary;
if(m_velocity.lengthSquared() > 0)
{
m_orientation = atan2f(m_velocity.y, m_velocity.x);
}
m_position += m_velocity;
Grid::getInstance()->applyExplosiveForce(0.5f *m_velocity.length(), m_position, 80);
// Check if the bullet is still in boundary.
boundary = Rectf(0, 0, (float) constants::WINDOW_WIDTH, (float) constants::WINDOW_HEIGHT);
if(!boundary.contains(Vector2f(m_position.x, m_position.y)))
{
setExpired();
}
}
void PlayerInventoryHud::draw() {
if(player.Interface & INTER_INVENTORY) {
if(player.bag) {
ARX_INTERFACE_DrawInventory(g_currentInventoryBag, Vec2i_ZERO);
CalculateInventoryCoordinates();
if(g_currentInventoryBag > 0) {
Rectf rect = Rectf(m_arrowsAnchor, 32.f * m_scale, 32.f * m_scale);
EERIEDrawBitmap(rect, 0.001f, m_heroInventoryUp, Color::white);
if(rect.contains(Vec2f(DANAEMouse))) {
GRenderer->SetBlendFunc(Renderer::BlendOne, Renderer::BlendOne);
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
SpecialCursor=CURSOR_INTERACTION_ON;
EERIEDrawBitmap(rect, 0.001f, m_heroInventoryUp, Color::white);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
SpecialCursor=CURSOR_INTERACTION_ON;
if(eeMouseDown1() || (eeMouseUp1() && DRAGINTER)) {
previousBag();
}
}
}
if(g_currentInventoryBag < player.bag-1) {
Rectf rect = Rectf(m_arrowsAnchor + Vec2f(0.f, 32.f + 5.f) * m_scale, 32.f * m_scale, 32.f * m_scale);
EERIEDrawBitmap(rect, 0.001f, m_heroInventoryDown, Color::white);
if(rect.contains(Vec2f(DANAEMouse))) {
GRenderer->SetBlendFunc(Renderer::BlendOne, Renderer::BlendOne);
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
EERIEDrawBitmap(rect, 0.001f, m_heroInventoryDown, Color::white);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
SpecialCursor=CURSOR_INTERACTION_ON;
if(eeMouseDown1() || (eeMouseUp1() && DRAGINTER)) {
nextBag();
}
}
}
}
} else if((player.Interface & INTER_INVENTORYALL) || bInventoryClosing) {
Vec2f anchorPos = anchorPosition();
//TODO see about these coords, might be calculated once only
const float fBag = (player.bag-1) * (-121 * m_scale);
const float fOffsetY = (121 * m_scale);
int iOffsetY = checked_range_cast<int>(fBag + fOffsetY);
int posx = checked_range_cast<int>(anchorPos.x);
int posy = checked_range_cast<int>(anchorPos.y + ((-3.f + 25 - 32) * m_scale));
for(int i = 0; i < player.bag; i++) {
Vec2f pos1 = Vec2f(posx + (45 * m_scale), static_cast<float>(posy + iOffsetY));
Vec2f pos2 = Vec2f(posx + (m_bagBackgroundSize.x * m_scale)*0.5f + (-16 * m_scale), posy+iOffsetY + (-5 * m_scale));
Vec2f pos3 = Vec2f(posx + (m_bagBackgroundSize.x * m_scale) + ((-45-32) * m_scale), posy+iOffsetY + (-15 * m_scale));
TextureContainer * tex = m_heroInventoryLink;
EERIEDrawBitmap(Rectf(pos1, tex->m_size.x, tex->m_size.y), 0.001f, tex, Color::white);
EERIEDrawBitmap(Rectf(pos2, tex->m_size.x, tex->m_size.y), 0.001f, tex, Color::white);
EERIEDrawBitmap(Rectf(pos3, tex->m_size.x, tex->m_size.y), 0.001f, tex, Color::white);
iOffsetY += checked_range_cast<int>(fOffsetY);
}
iOffsetY = checked_range_cast<int>(fBag);
for(short i = 0; i < player.bag; i++) {
ARX_INTERFACE_DrawInventory(i, Vec2i(0, iOffsetY));
iOffsetY += checked_range_cast<int>(fOffsetY);
}
}
}
//-----------------------------------------------------------------------------
// ARX Menu Rendering Func
// returns false if no menu needs to be displayed
//-----------------------------------------------------------------------------
bool ARX_Menu_Render() {
if(ARXmenu.currentmode == AMCM_OFF)
return false;
bool br = Menu2_Render();
if(br)
return br;
if(ARXmenu.currentmode == AMCM_OFF)
return false;
if(GInput->getMouseButton(Mouse::Button_0)) {
EERIEMouseButton = 1;
LastMouseClick = 1;
} else if(GInput->getMouseButton(Mouse::Button_1)) {
EERIEMouseButton = 2;
LastMouseClick = 2;
} else {
EERIEMouseButton = 0;
}
GRenderer->Clear(Renderer::ColorBuffer | Renderer::DepthBuffer);
FLYING_OVER = 0;
//-------------------------------------------------------------------------
if(ARXmenu.currentmode == AMCM_NEWQUEST && ARXmenu.mda) {
GRenderer->SetRenderState(Renderer::Fog, false);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
if(ARXmenu.mda->BookBackground != NULL) {
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
GRenderer->SetRenderState(Renderer::Fog, false);
GRenderer->SetRenderState(Renderer::DepthWrite, false);
GRenderer->SetRenderState(Renderer::DepthTest, false);
EERIEDrawBitmap2(Rectf(Vec2f(0, 0), g_size.width(), g_size.height()), 0.9f, ARXmenu.mda->BookBackground, Color::white);
}
BOOKZOOM = 1;
ARX_INTERFACE_ManageOpenedBook();
if(ARXmenu.mda) {
long DONE = 0;
if(player.Skill_Redistribute == 0 && player.Attribute_Redistribute == 0)
DONE = 1;
float ox, oy;
ox = g_sizeRatio.x;
oy = g_sizeRatio.y;
LASTBOOKBUTTON = BOOKBUTTON;
BOOKBUTTON = EERIEMouseButton;
g_sizeRatio.x = ox;
g_sizeRatio.y = oy;
if(!ARXmenu.mda->flyover[FLYING_OVER].empty() ) //=ARXmenu.mda->flyover[FLYING_OVER];
{
if(FLYING_OVER != OLD_FLYING_OVER) {
float fRandom = rnd() * 2;
int t = checked_range_cast<int>(fRandom);
pTextManage->Clear();
OLD_FLYING_OVER = FLYING_OVER;
UNICODE_ARXDrawTextCenteredScroll(hFontInGame,
(g_size.width() * 0.5f),
12,
(g_size.center().x) * 0.82f,
ARXmenu.mda->flyover[FLYING_OVER],
Color(232 + t, 204 + t, 143 + t),
1000,
0.01f,
2);
}
} else {
OLD_FLYING_OVER = -1;
}
Vec2f pos;
pos.x = 0;
pos.y = 313 * g_sizeRatio.y + (g_size.height() - 313 * g_sizeRatio.y) * 0.70f;
Vec2f size = g_sizeRatio;
size *= 100;
Color color = Color::none;
//---------------------------------------------------------------------
// Button QUICK GENERATION
pos.x = (g_size.width() - (513 * g_sizeRatio.x)) * 0.5f;
const Rectf quickGenerateButtonMouseTestRect(
pos,
size.x,
size.y
);
if(quickGenerateButtonMouseTestRect.contains(Vec2f(DANAEMouse))) {
SpecialCursor = CURSOR_INTERACTION_ON;
FLYING_OVER = BUTTON_QUICK_GENERATION;
if (EERIEMouseButton & 1) ;
else if ((!(EERIEMouseButton & 1)) && (LastMouseClick & 1))
{
QUICK_MOD++;
int iSkin = player.skin;
ARX_SOUND_PlayMenu(SND_MENU_CLICK);
if(bQuickGenFirstClick) {
ARX_PLAYER_MakeAverageHero();
bQuickGenFirstClick = false;
} else {
ARX_PLAYER_QuickGeneration();
}
player.skin = checked_range_cast<char>(iSkin);
}
color = Color(255, 255, 255);
}
else
color = Color(232, 204, 143);
pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_quickgen, static_cast<long>(pos.x), static_cast<long>(pos.y), color);
//---------------------------------------------------------------------
// Button SKIN
pos.x = g_size.width() * 0.5f;
const Rectf skinButtonMouseTestRect(
pos,
size.x,
size.y
);
if(skinButtonMouseTestRect.contains(Vec2f(DANAEMouse))) {
SpecialCursor = CURSOR_INTERACTION_ON;
FLYING_OVER = BUTTON_SKIN;
if(!(EERIEMouseButton & 1) && (LastMouseClick & 1)) {
SKIN_MOD++;
BOOKZOOM = 1;
ARX_SOUND_PlayMenu(SND_MENU_CLICK);
player.skin++;
if(player.skin > 3)
player.skin = 0;
ARX_PLAYER_Restore_Skin();
}
color = Color(255, 255, 255);
}
else
color = Color(232, 204, 143);
pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_skin, static_cast<long>(pos.x), static_cast<long>(pos.y), color);
//---------------------------------------------------------------------
// Button DONE
pos.x = g_size.width() - (g_size.width() - 513 * g_sizeRatio.x) * 0.5f - 40 * g_sizeRatio.x;
const Rectf doneButtonMouseTestRect(
pos,
size.x,
size.y
);
if(doneButtonMouseTestRect.contains(Vec2f(DANAEMouse))) {
if(DONE)
SpecialCursor = CURSOR_INTERACTION_ON;
FLYING_OVER = BUTTON_DONE;
if(DONE && !(EERIEMouseButton & 1) && (LastMouseClick & 1)) {
if(SKIN_MOD == 8 && QUICK_MOD == 10) {
SKIN_MOD = -2;
} else if(SKIN_MOD == -1) {
ARX_PLAYER_MakeSpHero();
player.skin = 4;
ARX_PLAYER_Restore_Skin();
SKIN_MOD = 0;
SP_HEAD = 1;
} else {
if(SP_HEAD) {
player.skin = 4;
ARX_PLAYER_Restore_Skin();
SP_HEAD = 0;
}
ARX_SOUND_PlayMenu(SND_MENU_CLICK);
bFadeInOut = true; //fade out
bFade = true; //active le fade
iFadeAction = AMCM_OFF;
}
} else {
if(DONE)
color = Color(255, 255, 255);
else
color = Color(192, 192, 192);
}
} else {
if(DONE)
color = Color(232, 204, 143);
else
color = Color(192, 192, 192);
}
if(SKIN_MOD < 0)
color = Color(255, 0, 255);
pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_done, static_cast<long>(pos.x), static_cast<long>(pos.y), color);
}
}
EERIE_LIGHT * light = lightHandleGet(torchLightHandle);
light->pos.x = 0.f + GInput->getMousePosAbs().x - (g_size.width() >> 1);
light->pos.y = 0.f + GInput->getMousePosAbs().y - (g_size.height() >> 1);
if(pTextManage) {
pTextManage->Update(framedelay);
pTextManage->Render();
}
if(ARXmenu.currentmode != AMCM_CREDITS)
ARX_INTERFACE_RenderCursor(true);
if(ARXmenu.currentmode == AMCM_NEWQUEST) {
if(ProcessFadeInOut(bFadeInOut, 0.1f)) {
switch(iFadeAction) {
case AMCM_OFF:
arxtime.resume();
ARX_MENU_NEW_QUEST_Clicked_QUIT();
iFadeAction = -1;
bFade = false;
fFadeInOut = 0.f;
if(pTextManage)
pTextManage->Clear();
break;
}
}
}
return true;
}
void ARX_INTERFACE_ManageOpenedBook_Finish(const Vec2f & mousePos, Rectf rect, float scale)
{
RenderState baseState = render3D().depthTest(false).fog(false);
Vec3f pos = Vec3f(0.f, 0.f, 2100.f);
EERIE_LIGHT * light = lightHandleGet(torchLightHandle);
EERIE_LIGHT tl = *light;
light->pos = Vec3f(500.f, -1960.f, 1590.f);
light->m_exists = true;
light->rgb = Color3f(0.6f, 0.7f, 0.9f);
light->intensity = 1.8f;
light->fallstart = 4520.f;
light->fallend = light->fallstart + 600.f;
RecalcLight(light);
Camera * oldcam = g_camera;
g_culledDynamicLights[0] = light;
g_culledDynamicLightsCount = 1;
Vec2i tmpPos(0);
GRenderer->SetAntialiasing(true);
float wave = timeWaveSin(g_platformTime.frameStart(), PlatformDurationMsf(1256.6370614f));
float ptDelta = toMs(g_platformTime.lastFrameDuration());
Camera bookcam;
bookcam.angle = Anglef();
bookcam.m_pos = Vec3f(0.f);
bookcam.focal = 500.f;
bookcam.cdepth = 2200.f;
for(size_t i = 0; i < RUNE_COUNT; i++) {
if(!gui::necklace.runes[i])
continue;
EERIE_3DOBJ * rune = gui::necklace.runes[i];
Vec2i projectionCenter = Vec2i(rect.topLeft() + (Vec2f(285, 36) + Vec2f(tmpPos) * Vec2f(45, 64)) * scale);
PrepareCamera(&bookcam, Rect(rect), projectionCenter);
if(player.hasRune((Rune)i)) {
Anglef angle;
if(rune->angle.getYaw() != 0.f) {
if(rune->angle.getYaw() > 300.f) {
rune->angle.setYaw(300.f);
}
angle.setYaw(wave * rune->angle.getYaw() * (1.0f / 40));
}
rune->angle.setYaw(rune->angle.getYaw() - ptDelta * 0.2f);
if(rune->angle.getYaw() < 0.f)
rune->angle.setYaw(0.f);
// Now draw the rune
TransformInfo t2(pos, glm::quat_cast(toRotationMatrix(angle)));
DrawEERIEInter(rune, t2, NULL, false, 0.f);
Rectf runeBox = UpdateBbox2d(*rune).toRect();
PopAllTriangleListOpaque(baseState);
tmpPos.x++;
if(tmpPos.x > 4) {
tmpPos.x = 0;
tmpPos.y++;
}
// TODO this is a workaround for vertexClipPositions being relative to viewport
Vec2f mousePosInViewport = mousePos - rect.topLeft();
// Checks for Mouse floating over a rune...
if(runeBox.contains(mousePosInViewport)) {
bool r = false;
for(size_t j = 0; j < rune->facelist.size(); j++) {
float n = PtIn2DPolyProj(rune->vertexClipPositions, &rune->facelist[j], mousePosInViewport.x, mousePosInViewport.y);
if(n != 0.f) {
r = true;
break;
}
}
if(r) {
TransformInfo t(pos, glm::quat_cast(toRotationMatrix(angle)));
DrawEERIEInter(rune, t, NULL, false, 0.f);
rune->angle.setYaw(rune->angle.getYaw() + ptDelta * 2.f);
PopAllTriangleListOpaque(baseState.blendAdditive());
cursorSetInteraction();
if(eeMouseDown1()) {
PlayerBookDrawRune((Rune)i);
}
}
}
TransformInfo t1(pos, quat_identity());
DrawEERIEInter(gui::necklace.lacet, t1, NULL, false, 0.f);
PopAllTriangleListOpaque(baseState);
}
}
*light = tl;
PrepareCamera(oldcam, g_size);
GRenderer->SetAntialiasing(false);
}
void TestbedApp::mouseDown( MouseEvent event )
{
#if defined( CINDER_GL_ES )
if( mLeftButton.contains( event.getPos() ) ) {
--testSelection;
if (testSelection < 0)
{
testSelection = testCount - 1;
}
return;
}
else if( mRightButton.contains( event.getPos() ) ) {
++testSelection;
if (testSelection == testCount)
{
testSelection = 0;
}
return;
}
#endif
int x = event.getPos().x;
int y = event.getPos().y;
int button = GLUT_NONE;
int state = GLUT_NONE;
int mod = GLUT_NONE;
if( event.isLeft() ) {
button = GLUT_LEFT_BUTTON;
if( event.isLeftDown() ) {
state = GLUT_DOWN;
}
}
else if( event.isRight() ) {
button = GLUT_RIGHT_BUTTON;
if( event.isRightDown() ) {
state = GLUT_DOWN;
}
}
if (button == GLUT_LEFT_BUTTON)
{
b2Vec2 p = ConvertScreenToWorld(x, y);
switch (fullscreenUI.Mouse(button, state, previousMouseState, p))
{
case FullscreenUI::e_SelectionTestPrevious:
testSelection = std::max(0, testSelection - 1);
break;
case FullscreenUI::e_SelectionTestNext:
if (g_testEntries[testSelection + 1].name) testSelection++;
break;
case FullscreenUI::e_SelectionParameterPrevious:
particleParameter.Decrement();
break;
case FullscreenUI::e_SelectionParameterNext:
particleParameter.Increment();
break;
default:
break;
}
if (state == GLUT_DOWN)
{
b2Vec2 p = ConvertScreenToWorld(x, y);
if (mod == GLUT_ACTIVE_SHIFT)
{
test->ShiftMouseDown(p);
}
else
{
test->MouseDown(p);
}
}
/*
if (state == GLUT_UP)
{
test->MouseUp(p);
}
*/
}
else if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
{
lastp = ConvertScreenToWorld(x, y);
rMouseDown = true;
}
/*
if (state == GLUT_UP)
{
rMouseDown = false;
}
*/
}
previousMouseState = state;
}
void ARX_INTERFACE_ManageOpenedBook_Finish(const Vec2f & mousePos)
{
Vec3f pos = Vec3f(0.f, 0.f, 2100.f);
Anglef angle = Anglef::ZERO;
EERIE_LIGHT * light = lightHandleGet(torchLightHandle);
EERIE_LIGHT tl = *light;
light->pos = Vec3f(500.f, -1960.f, 1590.f);
light->exist = 1;
light->rgb = Color3f(0.6f, 0.7f, 0.9f);
light->intensity = 1.8f;
light->fallstart = 4520.f;
light->fallend = light->fallstart + 600.f;
RecalcLight(light);
EERIE_CAMERA * oldcam = ACTIVECAM;
g_culledDynamicLights[0] = light;
g_culledDynamicLightsCount = 1;
Vec2i tmpPos = Vec2i_ZERO;
for(size_t i = 0; i < RUNE_COUNT; i++) {
if(!gui::necklace.runes[i])
continue;
EERIE_3DOBJ * rune = gui::necklace.runes[i];
bookcam.center.x = (382 + tmpPos.x * 45 + BOOKDEC.x) * g_sizeRatio.x;
bookcam.center.y = (100 + tmpPos.y * 64 + BOOKDEC.y) * g_sizeRatio.y;
SetActiveCamera(&bookcam);
PrepareCamera(&bookcam, g_size);
// First draw the lace
angle.setYaw(0.f);
if(player.hasRune((Rune)i)) {
TransformInfo t1(pos, glm::toQuat(toRotationMatrix(angle)));
DrawEERIEInter(gui::necklace.lacet, t1, NULL, false, 0.f);
if(rune->angle.getYaw() != 0.f) {
if(rune->angle.getYaw() > 300.f)
rune->angle.setYaw(300.f);
arxtime.update();
angle.setYaw(std::sin(arxtime.now_f() * (1.0f / 200)) * rune->angle.getYaw() * (1.0f / 40));
}
rune->angle.setYaw(rune->angle.getYaw() - g_framedelay * 0.2f);
if(rune->angle.getYaw() < 0.f)
rune->angle.setYaw(0.f);
GRenderer->SetRenderState(Renderer::DepthWrite, true);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
// Now draw the rune
TransformInfo t2(pos, glm::toQuat(toRotationMatrix(angle)));
DrawEERIEInter(rune, t2, NULL, false, 0.f);
Rectf runeBox = UpdateBbox2d(*rune).toRect();
PopAllTriangleListOpaque();
tmpPos.x++;
if(tmpPos.x > 4) {
tmpPos.x = 0;
tmpPos.y++;
}
// Checks for Mouse floating over a rune...
if(runeBox.contains(mousePos)) {
long r=0;
for(size_t j = 0; j < rune->facelist.size(); j++) {
float n = PtIn2DPolyProj(rune->vertexlist, &rune->facelist[j], mousePos.x, mousePos.y);
if(n!=0.f) {
r=1;
break;
}
}
if(r) {
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
GRenderer->SetBlendFunc(BlendOne, BlendOne);
TransformInfo t(pos, glm::toQuat(toRotationMatrix(angle)));
DrawEERIEInter(rune, t, NULL, false, 0.f);
rune->angle.setYaw(rune->angle.getYaw() + g_framedelay*2.f);
PopAllTriangleListOpaque();
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
SpecialCursor=CURSOR_INTERACTION_ON;
if(eeMouseDown1()) {
PlayerBookDrawRune((Rune)i);
}
}
}
}
}
GRenderer->SetCulling(CullCCW);
*light = tl;
SetActiveCamera(oldcam);
PrepareCamera(oldcam, g_size);
}
