static VALUE Drawable_get_scale(VALUE vSelf) {
// Get C++ object pointer from vSelf
Drawable *pSelf;
Data_Get_Struct(vSelf, Drawable, pSelf);
float x = pSelf->GetScaleX();
float y = pSelf->GetScaleY();
VALUE vArr = rb_ary_new();
rb_ary_push(vArr, rb_float_new(x));
rb_ary_push(vArr, rb_float_new(y));
return vArr;
}
void RenderingEngine::ClearExpired(){
simnode<Drawable>* node = _drawables->head;
while (node != NULL) {
Drawable* d = node->data;
if(d->IsExpired()){
node = _drawables->removeAndGetNext(node, !d->PreserveExpired());
continue;
}
node = node->next;
}
}
void AiEngine::drawMapDrawables() const
{
MapDrawablesSet::const_iterator it;
for (it = mapDrawables.begin(); it != mapDrawables.end(); it++)
{
mapCanvas.reset();
Drawable *drawable = *it;
drawable->draw(mapCanvas);
}
}
void AiEngine::drawScreenDrawables() const
{
ScreenDrawablesSet::const_iterator it;
for (it = screenDrawables.begin(); it != screenDrawables.end(); it++)
{
screenCanvas.reset();
Drawable *drawable = *it;
drawable->draw(screenCanvas);
}
}
Drawable::Drawable (const Drawable& other)
: Component (other.getName())
{
setInterceptsMouseClicks (false, false);
setPaintingIsUnclipped (true);
setComponentID (other.getComponentID());
setTransform (other.getTransform());
if (auto* clipPath = other.drawableClipPath.get())
setClipPath (clipPath->createCopy());
}
bool Scene::DoesIntersect(const Ray &ray)
{
for (std::vector<Drawable *>::const_iterator i = m_DrawableList.begin(); i != m_DrawableList.end(); i++) {
Drawable *d = *i;
if (d->Intersect(ray)) {
return true;
}
}
return false;
}
void GraphicsEngine::redo()
{
if (!redoStack.empty())
{
Drawable *obj = redoStack.back();
obj->load();
objects.push_back(obj);
std::stable_sort(objects.begin(), objects.end(), [](const Drawable* a, const Drawable* b) { return a->sortIndex() < b->sortIndex(); });
redoStack.pop_back();
undoStack.push_back(obj);
}
}
/**
* \brief Destroys from Lua all drawable objects created
* by this script.
*/
void LuaContext::destroy_drawables() {
std::set<Drawable*>::iterator it;
for (it = drawables.begin(); it != drawables.end(); ++it) {
Drawable* drawable = *it;
drawable->decrement_refcount();
if (drawable->get_refcount() == 0) {
delete drawable;
}
}
drawables.clear();
drawables_to_remove.clear();
}
void StaticTrace_addTile(StaticTrace* self, Tile* tile, uint32_t x, uint32_t y)
{
//if the position is correct
if(x < self->nbCasesX && y < self->nbCasesY && tile)
{
//Add the tile
self->tiles[x][y] = tile;
//And set its position
Drawable* tileDrawable = (Drawable*)tile;
tileDrawable->setPosition(tileDrawable, self->padX + x*self->sizeX, self->padY + y*self->sizeY);
}
}
void TextDraw::SetText(
Drawable & draw,
const Font & font, const std::string & text,
float x, float y, float scalex, float scaley,
float r, float g, float b,
VertexArray & output_array)
{
RenderText(font, text, x, y, scalex, scaley, output_array);
draw.SetTextures(font.GetFontTexture()->GetId());
draw.SetVertArray(&output_array);
draw.SetCull(false, false);
draw.SetColor(r, g, b, 1.0);
}
void BoxOctreeQuery::TestDrawables(Drawable** start, Drawable** end, bool inside)
{
while (start != end)
{
Drawable* drawable = *start++;
if ((drawable->GetDrawableFlags() & drawableFlags_) && (drawable->GetViewMask() & viewMask_))
{
if (inside || box_.IsInsideFast(drawable->GetWorldBoundingBox()))
result_.Push(drawable);
}
}
}
/**
* Draws an Image at the specified coordinates, with rotation and
* scaling along both axes.
* @param x The x-coordinate.
* @param y The y-coordinate.
* @param angle The amount of rotation.
* @param sx The scale factor along the x-axis. (1 = normal).
* @param sy The scale factor along the y-axis. (1 = normal).
* @param ox The offset along the x-axis.
* @param oy The offset along the y-axis.
**/
int w_draw(lua_State * L)
{
Drawable * drawable = luax_checktype<Drawable>(L, 1, "Drawable", GRAPHICS_DRAWABLE_T);
float x = (float)luaL_optnumber(L, 2, 0.0f);
float y = (float)luaL_optnumber(L, 3, 0.0f);
float angle = (float)luaL_optnumber(L, 4, 0.0f);
float sx = (float)luaL_optnumber(L, 5, 1.0f);
float sy = (float)luaL_optnumber(L, 6, sx);
float ox = (float)luaL_optnumber(L, 7, 0);
float oy = (float)luaL_optnumber(L, 8, 0);
drawable->draw(x, y, angle, sx, sy, ox, oy);
return 0;
}
void Gameplay::Draw() {
int activeAsteroids = 0;
for(auto it = asteroids.begin(); it != asteroids.end(); ++it) {
if(!(*it)->active)
continue;
activeAsteroids++;
(*it)->fillInstanceData(asteroidDraw->instances);
}
if(activeAsteroids > 0) {
asteroidDraw->setEffectTextures();
asteroidDraw->drawInstanced(activeAsteroids);
}
for(auto it = sceneMgr->Begin(); it != sceneMgr->End(); ++it) {
if(!(*it)->active)
continue;
(*it)->Draw();
}
laserDraw->setShader("laserEffect", "RenderLasers");
laserDraw->draw();
//draw glowy stuff
resourceMgr->md3dImmediateContext->RSSetViewports(1, &resourceMgr->viewports["DScale2"]);
resourceMgr->md3dImmediateContext->OMSetRenderTargets(1, &resourceMgr->renderTargets["DScale"], NULL);
resourceMgr->md3dImmediateContext->ClearRenderTargetView(resourceMgr->renderTargets["DScale"], reinterpret_cast<const float*>(&Colors::Black));
for(auto it = sceneMgr->Begin(); it != sceneMgr->End(); ++it)
{
if(!(*it)->glow || !(*it)->active)
continue;
Drawable* temp = (*it)->GetComponent<Drawable>();
if(temp)
{
temp->setShader("glowDraw", "RenderGlowy");
temp->setEffectVariables();
temp->setEffectTextures();
(*it)->Draw();
temp->setShader("betterPhongBump", "Render");
}
}
laserDraw->setShader("glowDraw", "RenderGlowy");
laserDraw->setEffectVariables();
laserDraw->draw();
laserDraw->points.clear();
glow->setEffectVariables();
glow->draw("DScale", "DScale2", "Pass2", "Original");
closeButton->Draw( );
}
void DrawableBase::execSyncV( FieldContainer &oFrom,
ConstFieldMaskArg whichField,
AspectOffsetStore &oOffsets,
ConstFieldMaskArg syncMode,
const UInt32 uiSyncInfo)
{
Drawable *pThis = static_cast<Drawable *>(this);
pThis->execSync(static_cast<Drawable *>(&oFrom),
whichField,
oOffsets,
syncMode,
uiSyncInfo);
}
void UpdateDrawablesWork(const WorkItem* item, unsigned threadIndex)
{
const FrameInfo& frame = *(reinterpret_cast<FrameInfo*>(item->aux_));
Drawable** start = reinterpret_cast<Drawable**>(item->start_);
Drawable** end = reinterpret_cast<Drawable**>(item->end_);
while (start != end)
{
Drawable* drawable = *start;
if (drawable)
drawable->Update(frame);
++start;
}
}
Drawable *Scene::getByTag(int tag) {
std::vector<Drawable *>::iterator it;
for(it = displayList.begin(); it < displayList.end(); ++it) {
Drawable *drawable = (Drawable *) *it;
if (drawable->getTag() == tag) {
return drawable;
}
}
return NULL;
}
void Buffer::createFromDrawable(Drawable &obj) {
shouldDelete = true;
if (obj.getW() > 512 || obj.getH() > 512)
throw RubyException(rb_eRuntimeError, "Drawable too big for a buffer.");
int width = obj.getW();
int height = obj.getH();
img = oslCreateImage(width, height, OSL_IN_VRAM, OSL_PF_8888);
if (!img) {
img = oslCreateImage(width, height, OSL_IN_RAM, OSL_PF_8888);
if (!img)
throw RubyException(rb_eRuntimeError, "Buffer could not be created");
}
else {
Buffer::registerInVram(img);
}
OSL_IMAGE *old = oslGetDrawBuffer();
setActual();
obj.clearMove();
obj.setPos(0, 0);
obj.draw();
obj.cancelMove();
oslSetDrawBuffer(old);
}
static VALUE Drawable_set_scale(VALUE vSelf, VALUE vScale) {
// Get C++ object pointer from vSelf
Drawable *pSelf;
Data_Get_Struct(vSelf, Drawable, pSelf);
if(ISNUM(vScale)) {
float f = (float)NUM2DBL(vScale);
pSelf->SetScale(f, f);
} else if(IS(vScale, rb_cArray)) {
float x = (float)NUM2DBL(rb_ary_entry(vScale, 0));
float y = (float)NUM2DBL(rb_ary_entry(vScale, 1));
pSelf->SetScale(x, y);
} else
rb_raise(rb_eTypeError, "wrong argument type(s)");
return Qnil;
}
bool Scene::DoesIntersect(const Ray &ray, double maxDistance)
{
for (std::vector<Drawable *>::const_iterator i = m_DrawableList.begin(); i != m_DrawableList.end(); i++) {
Drawable *d = *i;
Vector3d pos;
Vector3d normal;
if (d->Intersect(ray, pos, normal)) {
if ((ray.origin - pos).Length() < maxDistance)
return true;
}
}
return false;
}
bool SpaceshipGame::drawScene(Node* node, void* cookie)
{
Drawable* drawable = node->getDrawable();
if (drawable)
{
// Transparent nodes must be drawn last (stage 1)
bool isTransparent = (node == _glowNode);
// Skip transparent objects for stage 0
if ((!isTransparent && (int*)cookie == 0) || (isTransparent && (int*)cookie == (int*)1))
drawable->draw();
}
return true;
}
void Drawable::update(void) {
Drawable* d = _children;
if (_parent) {
_abs_xy.x = _parent->_abs_xy.x + _rel_xy.x;
_abs_xy.y = _parent->_abs_xy.y + _rel_xy.y;
} else {
_abs_xy.x = _rel_xy.x;
_abs_xy.y = _rel_xy.y;
}
while (d) {
d->update();
d = d->_next;
}
}
Image ProjectExporter::rescaleImageForIcon (Drawable& d, const int size)
{
if (DrawableImage* drawableImage = dynamic_cast<DrawableImage*> (&d))
{
Image im = SoftwareImageType().convert (drawableImage->getImage());
if (size == im.getWidth() && size == im.getHeight())
return im;
// (scale it down in stages for better resampling)
while (im.getWidth() > 2 * size && im.getHeight() > 2 * size)
im = im.rescaled (im.getWidth() / 2,
im.getHeight() / 2);
Image newIm (Image::ARGB, size, size, true, SoftwareImageType());
Graphics g (newIm);
g.drawImageWithin (im, 0, 0, size, size,
RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize, false);
return newIm;
}
Image im (Image::ARGB, size, size, true, SoftwareImageType());
Graphics g (im);
d.drawWithin (g, im.getBounds().toFloat(), RectanglePlacement::centred, 1.0f);
return im;
}
void arkanoid::Game::draw_object(Drawable &dr){
if(dr.is_visible()){
if(dr.d_id == 0){
dr_counter++;
dr.d_id = dr_counter;
drawed.push_back(dr);
}
float xdiff = static_cast<float>(actual_max_col) / static_cast<float>(default_max_col);
float ydiff = static_cast<float>(actual_max_row) / static_cast<float>(default_max_row);
unsigned start_r = round(dr.d_start_row * ydiff);
unsigned end_r = round(dr.d_end_row * ydiff);
unsigned start_c = round(dr.d_start_col * xdiff);
unsigned end_c = round(dr.d_end_col* xdiff);
use_color(dr.d_color);
for(unsigned i = start_r; i <= end_r; i++)
{
for(unsigned j = start_c; j <= end_c; j++)
{
mvprintw(i, j, "%c", dr.d_ch);
refresh();
}
}
}
}
void capture(Graphics& gl, const Lens& cam, const Pose& pose, Drawable& draw) {
validate();
glPushAttrib(GL_ALL_ATTRIB_BITS);
Vec3d pos = pose.pos();
Vec3d ux, uy, uz;
pose.unitVectors(ux, uy, uz);
mProjection = Matrix4d::perspective(90, 1, cam.near(), cam.far());
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFboId);
for (int face=0; face<6; face++) {
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT+face);
gl.viewport(0, 0, resolution(), resolution());
gl.clearColor(clearColor());
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
switch (face) {
case 0:
// GL_TEXTURE_CUBE_MAP_POSITIVE_X
mModelView = Matrix4d::lookAt(uz, uy, -ux, pos);
break;
case 1:
// GL_TEXTURE_CUBE_MAP_NEGATIVE_X
mModelView = Matrix4d::lookAt(-uz, uy, ux, pos);
break;
case 2:
// GL_TEXTURE_CUBE_MAP_POSITIVE_Y
mModelView = Matrix4d::lookAt(ux, -uz, uy, pos);
break;
case 3:
// GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
mModelView = Matrix4d::lookAt(ux, uz, -uy, pos);
break;
case 4:
// GL_TEXTURE_CUBE_MAP_POSITIVE_Z
mModelView = Matrix4d::lookAt(ux, uy, uz, pos);
break;
default:
// GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
mModelView = Matrix4d::lookAt(-ux, uy, -uz, pos);
break;
}
// apply camera transform:
gl.pushMatrix(gl.PROJECTION);
gl.loadMatrix(mProjection);
gl.pushMatrix(gl.MODELVIEW);
gl.loadMatrix(mModelView);
draw.onDraw(gl);
gl.popMatrix(gl.PROJECTION);
gl.popMatrix(gl.MODELVIEW);
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glPopAttrib();
}
void Ball::check_paddle(Drawable paddle){
if(this->intersect(paddle)){
glm::vec2 paddle_loc = paddle.get_location();
glm::vec2 paddle_dim = paddle.get_dimensions();
//Calulate istance from center of paddle
GLfloat distance = vertex.x - (paddle_loc.x + ((paddle_dim.x/2)));
GLfloat percentage = distance/(paddle_dim.x);
//Calculate new velocity
glm::vec2 prev_velocity = this->velocity;
velocity.x = 3 * percentage;
velocity.y = -1*abs(velocity.y);
//Normalize to maintain constant speed
// velocity = glm::normalize(velocity)*glm::length(prev_velocity);
}
}
IntersectionData KDTree::closestIntersection(const vector<Drawable *> &objList, const ray &viewRay) {
IntersectionData intersection;
intersection.obj = NULL;
intersection.time = std::numeric_limits<double>::max();
double tmp_time;
for(unsigned int i = 0; i < objList.size(); i++) {
Drawable *object = objList[i];
tmp_time = object->intersection(viewRay);
if(tmp_time > EPSILON && tmp_time < intersection.time) {
intersection.time = tmp_time;
intersection.obj = object;
}
}
return intersection;
}
bool TerrainSample::drawScene(Node* node)
{
Camera* camera = _scene->getActiveCamera();
Drawable* drawable = node->getDrawable();
if (dynamic_cast<Model*>(drawable))
{
if (!node->getBoundingSphere().intersects(camera->getFrustum()))
return true;
}
if (drawable)
{
bool wireframe = (node == _sky) ? false : _wireframe;
drawable->draw(wireframe);
}
return true;
}
void Object_destroy(Drawable* drawable)
{
Object* self = (Object*)drawable;
uint32_t i, j;
for(i=0; i < self->nbCasesX; i++)
{
for(j=0; j < self->nbCasesY; j++)
{
Drawable* tile = (Drawable*)(self->tiles[i][j]);
if(tile != NULL)
tile->destroy(tile);
}
free(self->tiles[i]);
}
free(self->tiles);
free(self);
}
static bool Cull(const Frustum & f, const Drawable & d)
{
const float radius = d.GetRadius();
Vec3 center = d.GetObjectCenter();
d.GetTransform().TransformVectorOut(center[0], center[1], center[2]);
for (int i = 0; i < 6; i++)
{
const float rd =
f.frustum[i][0] * center[0] +
f.frustum[i][1] * center[1] +
f.frustum[i][2] * center[2] +
f.frustum[i][3];
if (rd <= -radius)
return true;
}
return false;
}
////////////////////////////////////////////////////////////
/// Draw something on the window
////////////////////////////////////////////////////////////
void RenderWindow::Draw(const Drawable& Object) const
{
// Check whether we are called from the outside or from a previous call to Draw
if (!myIsDrawing)
{
myIsDrawing = true;
// Set our window as the current target for rendering
if (SetActive())
{
// Save the current render states and set the SFML ones
if (myPreserveStates)
{
GLCheck(glMatrixMode(GL_MODELVIEW)); GLCheck(glPushMatrix());
GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glPushMatrix());
GLCheck(glPushAttrib(GL_COLOR_BUFFER_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT |
GL_TEXTURE_BIT | GL_TRANSFORM_BIT | GL_VIEWPORT_BIT));
SetRenderStates();
}
// Set the window viewport and transform matrices
GLCheck(glViewport(0, 0, GetWidth(), GetHeight()));
GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glLoadMatrixf(myCurrentView->GetMatrix().Get4x4Elements()));
GLCheck(glMatrixMode(GL_MODELVIEW)); GLCheck(glLoadIdentity());
// Let the object draw itself
Object.Draw(*this);
// Restore render states
if (myPreserveStates)
{
GLCheck(glMatrixMode(GL_PROJECTION)); GLCheck(glPopMatrix());
GLCheck(glMatrixMode(GL_MODELVIEW)); GLCheck(glPopMatrix());
GLCheck(glPopAttrib());
}
}
myIsDrawing = false;
}
else
{
// We are already called from a previous Draw : we don't need to set the states again, just draw the object
Object.Draw(*this);
}
}