void moveB(int k){
switch(k){
case 0:
Bx = -5;
By = 6 + Ay;
onDraw();
break;
case 1:
By = 3 + Ay;
onDraw();
break;
case 2:
By = 0 + Ay;
onDraw();
break;
case 3:
By = -3 + Ay;
onDraw();
break;
default:
posB = 0;
Bx = 2;
By = 0;
onDraw();
break;
}
}
bool LayerAndroid::drawCanvas(SkCanvas* canvas, bool drawChildren, PaintStyle style)
{
if (!m_visible)
return false;
bool askScreenUpdate = false;
{
SkAutoCanvasRestore acr(canvas, true);
SkRect r;
r.set(m_clippingRect.x(), m_clippingRect.y(),
m_clippingRect.x() + m_clippingRect.width(),
m_clippingRect.y() + m_clippingRect.height());
canvas->clipRect(r);
SkMatrix matrix;
GLUtils::toSkMatrix(matrix, m_drawTransform);
SkMatrix canvasMatrix = canvas->getTotalMatrix();
matrix.postConcat(canvasMatrix);
canvas->setMatrix(matrix);
onDraw(canvas, m_drawOpacity, 0, style);
}
if (!drawChildren)
return false;
// When the layer is dirty, the UI thread should be notified to redraw.
askScreenUpdate |= drawChildrenCanvas(canvas, style);
return askScreenUpdate;
}
uint8_t today_process(uint8_t ev, uint16_t lparam, void* rparam)
{
switch(ev)
{
case EVENT_WINDOW_CREATED:
state = WALK;
// fallthrough
case PROCESS_EVENT_TIMER:
window_timer(CLOCK_SECOND * 5);
window_invalid(NULL);
return 0x80;
case EVENT_WINDOW_PAINT:
onDraw((tContext*)rparam);
break;
#if 0
case EVENT_KEY_PRESSED:
if (lparam == KEY_DOWN || lparam == KEY_UP)
{
state = 1 - state;
}
window_invalid(NULL);
break;
#endif
default:
return 0;
}
return 1;
}
void LayerBase::draw(const Region& inClip) const
{
// invalidate the region we'll update
Region clip(inClip); // copy-on-write, so no-op most of the time
// Remove the transparent area from the clipping region
const State& s = drawingState();
if (LIKELY(!s.transparentRegion.isEmpty())) {
clip.subtract(transparentRegionScreen);
if (clip.isEmpty()) {
// usually this won't happen because this should be taken care of
// by SurfaceFlinger::computeVisibleRegions()
return;
}
}
onDraw(clip);
/*
glDisable(GL_TEXTURE_2D);
glDisable(GL_DITHER);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glColor4x(0, 0x8000, 0, 0x10000);
drawRegion(transparentRegionScreen);
glDisable(GL_BLEND);
*/
}
void Layer::setAcquireFence(const sp<const DisplayDevice>& hw,
HWComposer::HWCLayerInterface& layer) {
int fenceFd = -1;
// TODO: there is a possible optimization here: we only need to set the
// acquire fence the first time a new buffer is acquired on EACH display.
#ifdef QCOM_HARDWARE
if (layer.getCompositionType() == HWC_OVERLAY ||
layer.getCompositionType() == HWC_BLIT) {
#else
if (layer.getCompositionType() == HWC_OVERLAY) {
#endif
sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence();
if (fence->isValid()) {
fenceFd = fence->dup();
if (fenceFd == -1) {
ALOGW("failed to dup layer fence, skipping sync: %d", errno);
}
}
}
layer.setAcquireFenceFd(fenceFd);
}
// ---------------------------------------------------------------------------
// drawing...
// ---------------------------------------------------------------------------
void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const {
onDraw(hw, clip);
}
void gearScenePreview::draw()
{
#ifdef LOG_GLERROR
int err=glGetError();
if(err!=GL_NO_ERROR)
{
printf("glGetError 0x%x\n", err);
}
#endif
if(!m_pSelectedObj) return;
monoWrapper::mono_engine_resize(m_pPreviewWorldPtr, m_cPos.x+getIamOnLayout()->getPos().x, (m_pRenderer->getViewPortSz().y)-(m_cPos.y+getIamOnLayout()->getPos().y+m_cSize.y), m_cSize.x/*+2.0f*/, m_cSize.y-getTopMarginOffsetHeight()/**//*+2.0f*/, 1.0f, 10000.0f);
onDraw();
//STATS
glViewport(m_cPos.x+getIamOnLayout()->getPos().x, (m_pRenderer->getViewPortSz().y)-(m_cPos.y+getIamOnLayout()->getPos().y+m_cSize.y), m_cSize.x, m_cSize.y-getTopMarginOffsetHeight());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D((int)0, (int)(m_cSize.x), (int)(m_cSize.y-getTopMarginOffsetHeight()), (int)0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(0, 0, -1);
glDisable(GL_DEPTH_TEST);
CHECK_GL_ERROR(geFontManager::g_pFontArial10_84Ptr->drawString("1 object selected", 5, 5+geFontManager::g_pFontArial10_84Ptr->getLineHeight(), m_cSize.x));
glEnable(GL_DEPTH_TEST);
glPopMatrix();
//
}
// This can be improved by collecting the dirty regions and painting
// when the event loop goes idle
void pxWindowNative::invalidateRectInternal(pxRect *r)
{
Display* display = mDisplayRef.getDisplay();
GC gc=XCreateGC(display, win, 0, NULL);
pxSurfaceNativeDesc d;
d.display = display;
d.drawable = win;
d.gc = gc;
if (r)
{
// Set up clip area
XRectangle xr;
xr.x = r->left();
xr.y = r->top();
xr.width = r->width();
xr.height = r->height();
XSetClipRectangles(display, gc, 0, 0, &xr, 1, Unsorted);
}
onDraw(&d);
XFreeGC(display, gc);
}
void draw(sf::RenderTarget& target, sf::RenderStates states) const
{
if (m_isLoaded)
{
onDraw(target, states);
}
}
void LayerBase::draw(const Region& clip) const
{
// reset GL state
glEnable(GL_SCISSOR_TEST);
onDraw(clip);
}
void ComponentWidget::draw()
{
// check visibility
if( !mWidgetDesc->widget_visible )
return;
Brush* brush = Brush::getSingletonPtr();
// check and store clip region
Rect prevClipRegion = brush->getClipRegion();
if ( prevClipRegion.getIntersection(Rect(mTexturePosition,mWidgetDesc->widget_dimensions.size)) == Rect::ZERO )
return;
// set clip region to dimensions
brush->setClipRegion(Rect(mTexturePosition,mWidgetDesc->widget_dimensions.size).getIntersection(prevClipRegion));
// Set color before drawing operations
brush->setColor(mWidgetDesc->widget_baseColor);
// Set opacity before drawing operations
brush->setOpacity(getAbsoluteOpacity());
// draw self
onDraw();
if(!dynamic_cast<ComponentWidgetDesc*>(mWidgetDesc)->componentwidget_clipComponentsToDimensions)
brush->setClipRegion(prevClipRegion);
// draw components
for(std::map<Ogre::String,Widget*>::iterator it = mComponents.begin(); it != mComponents.end(); ++it)
(*it).second->draw();
// restore clip region
brush->setClipRegion(prevClipRegion);
}
bool engine::update()
{
std::chrono::duration<float> dt(std::chrono::system_clock::now() - curTime);
// обработаем пользовательский ввод
XEvent evt;
for (int i = 0; i < XPending(data.display); i++)
{
XNextEvent(data.display, &evt);
switch (evt.type)
{
case KeyPress:
{
auto event = reinterpret_cast<XKeyEvent *>(&evt);
if(event->keycode == 61) return false;
break;
}
default:
break;
}
}
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // стерли буффер
if(onDraw) onDraw(dt.count()); // позвали что-то, что рисует
glXSwapBuffers(data.display,data.window); // показали буффер
curTime = std::chrono::system_clock::now();
return true;
}
void LayerBase::drawForSreenShot()
{
const DisplayHardware& hw(graphicPlane(0).displayHardware());
setFiltering(true);
onDraw( Region(hw.bounds()) );
setFiltering(false);
}
void LayerBase::draw(const Region& clip) const
{
//Dont draw External-only layers
if (isLayerExternalOnly(getLayer())) {
return;
}
onDraw(clip);
}
extern uint8_t upgrade_process(uint8_t ev, uint16_t lparam, void* rparam)
{
switch(ev)
{
case EVENT_WINDOW_CREATED:
window_timer(CLOCK_SECOND * 30);
break;
case EVENT_FIRMWARE_UPGRADE:
if (rparam == (void*)PROGRESS_TIMEOUT)
break;
if (rparam == (void*)-1)
{
progress = PROGRESS_FINISH;
window_timer(0);
}
else
{
progress = (long)rparam * 100/(230UL*1024);
window_timer(CLOCK_SECOND * 30);
}
window_invalid(NULL);
break;
case EVENT_WINDOW_PAINT:
onDraw((tContext*)rparam);
break;
case EVENT_EXIT_PRESSED:
if (progress != PROGRESS_FINISH || progress != PROGRESS_TIMEOUT)
return 1;
break;
case PROCESS_EVENT_TIMER:
if (progress != PROGRESS_FINISH)
{
progress = PROGRESS_TIMEOUT;
window_invalid(NULL);
}
break;
case EVENT_KEY_PRESSED:
if (lparam == KEY_ENTER)
{
if (progress == PROGRESS_FINISH)
{
int ret = CheckUpgrade();
printf("CheckUpgrade() %d\n", ret);
if (ret == 0xff)
system_reset();
else
window_close();
}
else if (progress == PROGRESS_TIMEOUT)
{
window_close();
}
}
break;
}
return 1;
}
void Entity::drawCurrent(sf::RenderTarget& target, sf::RenderStates states) const
{
// Call draw on self then on components
onDraw(target, states);
for (Component* component : components)
{
component->onDraw(target, states);
}
}
inline void OmniStereoGraphicsRenderer::onDrawOmni(OmniStereo& omni) {
graphics().error("start onDraw");
mShader.begin();
mOmni.uniforms(mShader);
graphics().pushMatrix(graphics().MODELVIEW);
onDraw(graphics());
graphics().popMatrix(graphics().MODELVIEW);
mShader.end();
}
inline void OmniApp::onDrawOmni(OmniStereo& omni) {
graphics().error("start onDraw");
mShader.begin();
mOmni.uniforms(mShader);
onDraw(graphics());
mShader.end();
}
void LayerBase::drawForSreenShot()
{
//Dont draw External-only layers
if (isLayerExternalOnly(getLayer())) {
return;
}
const DisplayHardware& hw(graphicPlane(0).displayHardware());
setFiltering(true);
onDraw( Region(hw.bounds()) );
setFiltering(false);
}
void Layer::draw(SkCanvas* canvas, SkScalar opacity) {
#if 0
SkString str1, str2;
// getMatrix().toDumpString(&str1);
// getChildrenMatrix().toDumpString(&str2);
SkDebugf("--- drawlayer %p opacity %g size [%g %g] pos [%g %g] matrix %s children %s\n",
this, opacity * getOpacity(), m_size.width(), m_size.height(),
m_position.fX, m_position.fY, str1.c_str(), str2.c_str());
#endif
opacity = SkScalarMul(opacity, getOpacity());
if (opacity <= 0) {
// SkDebugf("---- abort drawing %p opacity %g\n", this, opacity);
return;
}
SkAutoCanvasRestore acr(canvas, true);
// apply our local transform
{
SkMatrix tmp;
getLocalTransform(&tmp);
if (shouldInheritFromRootTransform()) {
// should we also apply the root's childrenMatrix?
canvas->setMatrix(getRootLayer()->getMatrix());
}
canvas->concat(tmp);
}
onDraw(canvas, opacity);
#ifdef DEBUG_DRAW_LAYER_BOUNDS
{
SkRect r = SkRect::MakeSize(getSize());
SkPaint p;
p.setAntiAlias(true);
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(SkIntToScalar(2));
p.setColor(0xFFFF44DD);
canvas->drawRect(r, p);
canvas->drawLine(r.fLeft, r.fTop, r.fRight, r.fBottom, p);
canvas->drawLine(r.fLeft, r.fBottom, r.fRight, r.fTop, p);
}
#endif
int count = countChildren();
if (count > 0) {
canvas->concat(getChildrenMatrix());
for (int i = 0; i < count; i++) {
getChild(i)->draw(canvas, opacity);
}
}
}
void View::draw(const kt::view::DrawParams &p) {
if (isHidden()) return;
ci::gl::ScopedModelMatrix smm;
auto ctx = ci::gl::context();
ctx->getModelMatrixStack().back() *= getLocalTransform();
onDraw(p);
for (auto& it : mChildren) {
if (it) it->draw(p);
}
}
void View::draw(SkCanvas & canvas)
{
SkAutoCanvasRestore restore(&canvas, true);
canvas.concat(m_props.matrix());
canvas.clipRect(m_props.localRect(), SkRegion::kIntersect_Op, true);
onDraw(canvas);
for (View* v : m_children) {
v->draw(canvas);
}
}
void animation(int k){
struct timespec i;
i.tv_sec=0; i.tv_nsec=50000000;
switch(k){
case 0:
while(bary<9.8){
nanosleep(&i, NULL);
bary+=.2;
onDraw();
}
while(barx>-4.8){
nanosleep(&i, NULL);
barx-=.2;
onDraw();
}
while(bary>3.2){
nanosleep(&i, NULL);
bary-=.2;
onDraw();
}
bary=3; barx=-5;
break;
case 1:
while(bary>0.2){
nanosleep(&i, NULL);
bary-=.2;
onDraw();
}
bary=0;
break;
case 2:
while(bary>-2.8){
nanosleep(&i, NULL);
bary-=.2;
onDraw();
}
bary=-3;
break;
}
}
void GroupDrawable::draw(Render& render, const glm::mat4& transformation)
{
if(!m_canDraw)
return;
glm::mat4 mvp = transformation*getMatrix();
for(std::list<Drawable*>::iterator it = m_drawables.begin(); it != m_drawables.end(); it++)
if((*it))
(*it)->draw(render, mvp);
if(m_material)
m_material->enableShader();
if(m_staticToCamera)
onDraw(render, mvp);
else
onDraw(render, render.getCamera().getMatrix() * mvp);
if(m_material)
m_material->disableShader();
}
void Mesh::drawAOC(ICamera& camera) {
mProgramAOColor->use();
// core::Uniform::push(mULCTextureMap, FILLWAVE_DIFFUSE_ATTACHMENT);
core::Uniform::push(mULCSampleRadius, FILLWAVE_AO_SAMPLE_RADIUS);
core::Uniform::push(mULCProjectionMatrix, camera.getProjection());
// core::Uniform::push(mULCRandomVectors, camera.getEye() * mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
}
void Mesh::drawAOG(ICamera& camera) {
mProgramAOGeometry->use();
core::Uniform::push(mULCMVPAmbientOcclusion,
camera.getViewProjection() * mPhysicsMMC);
core::Uniform::push(mULCPositionAmbientOcclusion,
camera.getEye() * mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
}
void Node::draw(sf::RenderTarget& target, const sf::Transform& parentTransform) const
{
//NOOP if this Node is not visible
if(m_visible)
{
// combine the parent transform with the node's one
sf::Transform combinedTransform = parentTransform * m_transform;
// let the node draw itself
onDraw(target, combinedTransform);
// draw its children
for (std::size_t i = 0; i < m_children.size(); ++i)
m_children[i]->draw(target, combinedTransform);
}
}
// start the draw loop
void start()
{
printf("starting app\n");
while (!mWindow.shouldClose() )
{
mWindow.setViewport();
//glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
onDraw();
mWindow.swapBuffers();
glfwPollEvents();
}
}
void Mesh::drawDepth(ICamera& camera) {
if (isPSC()) {
mProgramShadow->use();
core::Uniform::push(mULCMVPShadow,
camera.getViewProjection() * mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
core::Program::disusePrograms();
}
}
void CGame::run()
{
sf::Clock clock;
sf::Time timeSinceLastUpdate = sf::Time::Zero;
while(mWindow.isOpen())
{
sf::Time elapsedTime = clock.restart();
timeSinceLastUpdate += elapsedTime;
while(timeSinceLastUpdate > TimePerFrame)
{
timeSinceLastUpdate -= TimePerFrame;
processEvents();
onUpdate(TimePerFrame);
}
onDraw();
}
}
void Mesh::drawDepthColor(
ICamera& camera,
glm::vec3& /*xxx double check position*/) {
if (isPSC()) {
mProgramShadowColor->use();
core::Uniform::push(mULCMVPShadowColor,
camera.getViewProjection() * mPhysicsMMC);
core::Uniform::push(mULCModelMatrixShadowColor, mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
core::Program::disusePrograms();
}
}
