Render a debugging hint for the arcball tool.

@param gl GL class for rendering-
185670
@SuppressWarnings("unused")
  public void debugRender(GL2 gl) {
    if (!DEBUG || (startcamera == null)) {
      return;
    }
    gl.glLineWidth(3f);
    gl.glColor4f(1.f, 0.f, 0.f, .66f);
    gl.glBegin(GL.GL_LINES);
    gl.glVertex3f(0.f, 0.f, 0.f);
    double rot = startangle - startcamera.getRotationZ();
    gl.glVertex3f((float) FastMath.cos(rot) * 4.f, (float) -FastMath.sin(rot) * 4.f, 0.f);
    gl.glVertex3f((float) FastMath.cos(rot) * 1.f, (float) -FastMath.sin(rot) * 1.f, 0.f);
    gl.glVertex3f((float) FastMath.cos(rot) * 1.f, (float) -FastMath.sin(rot) * 1.f, 1.f);
    gl.glEnd();
  }
520906
public void render(Graphic g,
                       Viewer viewer,
                       Origin origin,
                       Shape transformable,
                       List<Collision> cacheColls,
                       Map<Collision, Rectangle> cacheRect)
    {
        if (showCollision)
        {
            final int size = cacheColls.size();
            for (int i = 0; i < size; i++)
            {
                final Collision collision = cacheColls.get(i);
                if (Collision.AUTOMATIC == collision)
                {
                    final int x = (int) Math.round(origin.getX(viewer.getViewpointX(transformable.getX()),
                                                               transformable.getWidth()));
                    final int y = (int) Math.floor(origin.getY(viewer.getViewpointY(transformable.getY()),
                                                               transformable.getHeight()));
                    g.drawRect(x, y, transformable.getWidth(), transformable.getHeight(), false);
                }
                else
                {
                    final Area area = cacheRect.get(collision);
                    final int x = (int) Math.round(viewer.getViewpointX(area.getX()));
                    final int y = (int) Math.floor(viewer.getViewpointY(area.getY())) - area.getHeight();
                    g.drawRect(x, y, area.getWidth(), area.getHeight(), false);
                }
            }
        }
    }
1154802
def debug_sphere_out(self, p: Union[Unit, Point2, Point3], r: Union[int, float], color=None):
        
        self._debug_spheres.append(
            debug_pb.DebugSphere(p=self.to_debug_point(p), r=r, color=self.to_debug_color(color))
        )
573922
public void render (Graphics2D gfx)
    {
        Component host = _host.getComponent();

        int x = _bounds.x, y = _bounds.y;

        if (_centerLabel != null) {
            // render the centerpiece label
            _centerLabel.paint(gfx, x + _centerLabel.closedBounds.x,
                               y + _centerLabel.closedBounds.y, this);
        }

        // render each of our items in turn
        int icount = _items.size();
        for (int i = 0; i < icount; i++) {
            RadialMenuItem item = _items.get(i);
            if (!item.isIncluded(this)) {
                continue;
            }
            // we have to wait and render the active item last
            if (item != _activeItem) {
                item.render(host, this, gfx, x + item.closedBounds.x, y + item.closedBounds.y);
            }
        }

        if (_activeItem != null) {
            _activeItem.render(host, this, gfx, x + _activeItem.closedBounds.x,
                               y + _activeItem.closedBounds.y);
        }

        // render our bounds
//         gfx.setColor(Color.green);
//         gfx.draw(_bounds);
//         gfx.setColor(Color.blue);
//         gfx.draw(_tbounds);
    }
151147
@Override
    public void render(Graphic g, Handlables featurables)
    {
        for (final Renderable renderable : featurables.get(Renderable.class))
        {
            renderable.render(g);
        }
    }
177482
function RenderProgramWrapper(layer, shader) {
    this.shader = shader;
    this.layer = layer;
    this.context = layer.context;
    this.draw = function() {};

    this.array_size = 16;
    this.max_size = 1024;
    this._indexArray = new Uint16Array(6 * this.array_size);
    this._indexBuffer = layer.context.createBuffer();
}
364171
void draw(GLShader shader, InternalTransform xform, int tint,
            float dx, float dy, float dw, float dh) {
    draw(shader, xform, tint, dx, dy, dw, dh,
         0, 0, (repeatX ? dw : width()), (repeatY ? dh : height()));
  }
32960
function( gl ){
    this._set = 0;

    var enableBlend       = getP( gl, ~~GL_BLEND ),
        enableCullface    = getP( gl, ~~GL_CULL_FACE ),
        enableDepthTest   = getP( gl, ~~GL_DEPTH_TEST ),
        enableDither      = getP( gl, ~~GL_DITHER ),
        enablePolyOffset  = getP( gl, ~~GL_POLYGON_OFFSET_FILL ),
        // enableACoverage   = getP( gl, ~~GL_SAMPLE_ALPHA_TO_COVERAGE ),
        // enableCoverage    = getP( gl, ~~GL_SAMPLE_COVERAGE ),
        enableScissor     = getP( gl, ~~GL_SCISSOR_TEST ),
        enableStencil     = getP( gl, ~~GL_STENCIL_TEST ),

        blendSrcRGB       = getP( gl, ~~GL_BLEND_SRC_RGB ),
        blendDstRGB       = getP( gl, ~~GL_BLEND_DST_RGB ),
        blendSrcAlpha     = getP( gl, ~~GL_BLEND_SRC_ALPHA ),
        blendDstAlpha     = getP( gl, ~~GL_BLEND_DST_ALPHA ),
        blendEqRgb        = getP( gl, ~~GL_BLEND_EQUATION_RGB ),
        blendEqAlpha      = getP( gl, ~~GL_BLEND_EQUATION_ALPHA ),
        stencilFunc       = getP( gl, ~~GL_STENCIL_FUNC ),
        stencilRef        = getP( gl, ~~GL_STENCIL_REF ),
        stencilValueMask  = getP( gl, ~~GL_STENCIL_VALUE_MASK ),
        stencilWriteMask  = getP( gl, ~~GL_STENCIL_WRITEMASK ),
        stencilOpFail     = getP( gl, ~~GL_STENCIL_FAIL ),
        stencilOpZfail    = getP( gl, ~~GL_STENCIL_PASS_DEPTH_FAIL ),
        stencilOpZpass    = getP( gl, ~~GL_STENCIL_PASS_DEPTH_PASS ),
        stencilBFunc      = getP( gl, ~~GL_STENCIL_BACK_FUNC ),
        stencilBRef       = getP( gl, ~~GL_STENCIL_BACK_REF ),
        stencilBValueMask = getP( gl, ~~GL_STENCIL_BACK_VALUE_MASK ),
        stencilBWriteMask = getP( gl, ~~GL_STENCIL_BACK_WRITEMASK ),
        stencilBOpFail    = getP( gl, ~~GL_STENCIL_BACK_FAIL ),
        stencilBOpZfail   = getP( gl, ~~GL_STENCIL_BACK_PASS_DEPTH_FAIL ),
        stencilBOpZpass   = getP( gl, ~~GL_STENCIL_BACK_PASS_DEPTH_PASS ),

        polyOffsetFactor  = getP( gl, ~~GL_POLYGON_OFFSET_FACTOR ),
        polyOffsetUnits   = getP( gl, ~~GL_POLYGON_OFFSET_UNITS ),
        scissorBox        = getP( gl, ~~GL_SCISSOR_BOX ),
        colorMaskArray    = getP( gl, ~~GL_COLOR_WRITEMASK ),
        depthWriteMask    = getP( gl, ~~GL_DEPTH_WRITEMASK ),
        blendColor        = getP( gl, ~~GL_BLEND_COLOR ),
        viewport          = getP( gl, ~~GL_VIEWPORT ),
        depthRange        = getP( gl, ~~GL_DEPTH_RANGE ),
        lineWidth         = getP( gl, ~~GL_LINE_WIDTH );




    this.enableBlend( enableBlend );

    if( blendSrcRGB !== blendSrcAlpha || blendDstRGB !== blendDstAlpha ) {
      this.blendFuncSeparate(
        blendSrcRGB,
        blendDstRGB,
        blendSrcAlpha,
        blendDstAlpha
      );
    } else {
      this.blendFunc(
        blendSrcRGB,
        blendDstRGB
      );
    }

    if( blendEqRgb !== blendEqAlpha ) {
      this.blendEquationSeparate(
        blendEqRgb,
        blendEqAlpha
      );
    } else {
      this.blendEquation(
        blendEqRgb
      );
    }



    this.enableStencil( enableStencil );
    if( stencilFunc      !== stencilBFunc     ||
        stencilRef       !== stencilBRef      ||
        stencilValueMask !== stencilBValueMask ) {
      this.stencilFuncSeparate(
        stencilFunc,
        stencilRef,
        stencilValueMask,
        stencilBFunc,
        stencilBRef,
        stencilBValueMask
      );
    } else {
      this.stencilFunc(
        stencilFunc,
        stencilRef,
        stencilValueMask
      );

    }

    if( stencilOpFail  !== stencilBOpFail   ||
        stencilOpZfail !== stencilBOpZfail  ||
        stencilOpZpass !== stencilBOpZpass ) {
      this.stencilOpSeparate(
        stencilOpFail,
        stencilOpZfail,
        stencilOpZpass,
        stencilBOpFail,
        stencilBOpZfail,
        stencilBOpZpass
      );
    } else {
      this.stencilOp(
        stencilOpFail,
        stencilOpZfail,
        stencilOpZpass
      );
    }

    if( stencilWriteMask !== stencilBWriteMask ){
      this.stencilMaskSeparate( stencilWriteMask, stencilBWriteMask );
    } else {
      this.stencilMask( stencilWriteMask );
    }


    // DEPTH
    // -----

    this.depthFunc(
      gl.getParameter( ~~GL_DEPTH_FUNC )
    );

    this.enableDepthTest( enableDepthTest );

    // FACE CULLING
    // ------------
    this.cullFace(
      gl.getParameter( ~~GL_CULL_FACE_MODE )
    );

    this.enableCullface( enableCullface );

    this.frontFace(
      gl.getParameter( ~~GL_FRONT_FACE )
    );


    // POLYGON_OFFSET

    this.enablePolygonOffset( enablePolyOffset  );

    this.polygonOffset( polyOffsetFactor, polyOffsetUnits );

    // SCISSOR

    this.enableScissor   ( enableScissor     );
    this.scissor(
      scissorBox[0],
      scissorBox[1],
      scissorBox[2],
      scissorBox[3]
    );
    // DITHER
    // ------

    this.enableDither    ( enableDither      );

    this.colorMask( colorMaskArray[0], colorMaskArray[1], colorMaskArray[2], colorMaskArray[3] );

    this.depthMask( depthWriteMask );
    //this.enableACoverage ( enableACoverage   );
    //this.enableCoverage  ( enableCoverage    );

    this.blendColor(
      blendColor[0],
      blendColor[1],
      blendColor[2],
      blendColor[3]
    );

    this.viewport(
      viewport[0],
      viewport[1],
      viewport[2],
      viewport[3]
    );

    this.depthRange(
      depthRange[0],
      depthRange[1]
    );

    this.lineWidth( lineWidth );

  }
1336486
public void render (Component host, RadialMenu menu, Graphics2D gfx, int x, int y)
    {
        paint(gfx, x, y, menu);
    }
519388
function(){

    var gl = this.gl;
    gl.bindRenderbuffer(    RENDERBUFFER,  this.id );
    gl.renderbufferStorage( RENDERBUFFER,  this.format , this.width, this.height );
    gl.bindRenderbuffer(    RENDERBUFFER,  null );

  }
335824
def debug(self, *msg):
        
        label = colors.yellow("DEBUG")
        self._msg(label, *msg)
97493
def to_debug_color(self, color):
        
        if color is None:
            return debug_pb.Color(r=255, g=255, b=255)
        else:
            r = getattr(color, "r", getattr(color, "x", 255))
            g = getattr(color, "g", getattr(color, "y", 255))
            b = getattr(color, "b", getattr(color, "z", 255))
            if max(r, g, b) <= 1:
                r *= 255
                g *= 255
                b *= 255

            return debug_pb.Color(r=int(r), g=int(g), b=int(b))
108255
public function render() {
        if (!$this->_enableXDebugOverlay) {
            ini_set('xdebug.overload_var_dump', 'off');
        }
        $debuggerCount = count($this->_debuggers);
        $this->setName(str_replace('{count}', '{' . $debuggerCount . '}', self::NAME));
        parent::render();
    }
688189
protected void renderDebugBoundingBox(Graphics2D context) {
		/* */java.awt.Color previousColor = context.getColor();
		context.setColor(java.awt.Color.RED);
		context.draw(getBoundingBox());
		context.setColor(previousColor);/* */
	}
951322
@Override
    public void debug(Object object, Object... objects) {
        if (isDebugEnabled()) {
            StringBuilder result = new StringBuilder();
            result.append(object.toString());
            for (Object obj : objects) {
                if (obj == null) {
                    result.append("null");
                } else {
                    result.append(obj.toString());
                }
            }
            debugString(result.toString());
        }
    }
1117475
public static void debug(boolean debug) {
        NotificationCenter.DBG =
            NotificationEffect.DBG =
            NotificationBuilder.DBG =
            NotificationEntry.DBG =
            NotificationHandler.DBG =
            NotificationRemote.DBG =
            NotificationRemoteCallback.DBG =
            NotificationLocal.DBG =
            NotificationGlobal.DBG =
            NotificationView.DBG =
            NotificationViewCallback.DBG =
            NotificationRootView.DBG =
            NotificationBoard.DBG =
            NotificationBoardCallback.DBG =
            ViewWrapper.DBG =
            ViewSwitcherWrapper.DBG =
            ChildViewManager.DBG =
            DBG = debug;
    }
857129
public final static void debug(Object... msg)
    {
        if ( DEBUG.get() ) {
            StringBuilder sb = new StringBuilder();
            for ( Object m : msg )
                sb.append(m);
            Console.debug.println("// Debug: " + sb.toString());
        }
    }