void Box2DDebugDraw::DrawTransform(const b2Transform& xf) { b2Vec2 p1 = xf.p, p2; const float32 k_axisScale = 0.8f; p2 = p1 + b2Vec2(k_axisScale * xf.q.c, k_axisScale * xf.q.s); DrawSegment(p1, p2, b2Color(1.0f, 0.0f, 0.0f)); p2 = p1 + b2Vec2(-k_axisScale * xf.q.s, k_axisScale * xf.q.c); DrawSegment(p1, p2, b2Color(0.0f, 1.0f, 0.0f)); /*b2Vec2 p1 = xf.position, p2; const float32 k_axisScale = 0.4f; glBegin(GL_LINES); glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(p1.x, p1.y); p2 = p1 + k_axisScale * xf.R.col1; glVertex2f(p2.x, p2.y); glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(p1.x, p1.y); p2 = p1 + k_axisScale * xf.R.col2; glVertex2f(p2.x, p2.y); glEnd();*/ }
// back-end static void DrawHistograms () { VisualizationData vd; int i; double step = 1; if( InitVisualization( &vd ) ) { if( vd.hist_width < MIN_HIST_WIDTH ) { DrawHistogramAsDiagram( vd.cy, vd.paint_width, vd.hist_count ); step = 0.5*vd.paint_width / (((vd.hist_count | 7) + 1)/2 + 1.); } else { DrawHistogramFull( vd.cy, step = vd.hist_width, vd.hist_count ); } } if(!differentialView) return; differentialView = 0; DrawSegment( MarginX + MarginW, vd.cy, NULL, NULL, PEN_NONE ); for( i=0; i<vd.hist_count; i++ ) { int index = currFirst + i; int x = MarginX + MarginW + index * step + step/2; DrawSegment((int) x, GetValueY( GetPvScore(index) ), NULL, NULL, PEN_ANY ); } differentialView = 1; }
// back-end static void DrawLineEx (int x1, int y1, int x2, int y2, int penType) { int savX, savY; DrawSegment( x1, y1, &savX, &savY, PEN_NONE ); DrawSegment( x2, y2, NULL, NULL, penType ); DrawSegment( savX, savY, NULL, NULL, PEN_NONE ); }
DebugRenderer::~DebugRenderer () { #ifndef NO_DEBUG_RENDERER const float32 k_impulseScale = 0.1f; const float32 k_axisScale = 0.3f; const bool drawFrictionImpulse = true; const bool drawContactNormals = true; const bool drawContactImpulse = true; for (int i = 0; i < _pointCount; ++i) { const ContactPoint* point = &_points[i]; if (point->state == b2_addState) { DrawPoint(point->position, 0.2f, b2Color(0.3f, 0.95f, 0.3f)); } else if (point->state == b2_persistState) { DrawPoint(point->position, 0.1f, b2Color(0.3f, 0.3f, 0.95f)); } if (drawContactNormals) { const b2Vec2& p1 = point->position; const b2Vec2 p2 = p1 + k_axisScale * point->normal; DrawSegment(p1, p2, b2Color(0.9f, 0.9f, 0.9f)); } if (drawContactImpulse) { const b2Vec2& p1 = point->position; const b2Vec2 p2 = p1 + k_impulseScale * point->normalImpulse * point->normal; DrawSegmentWithAlpha(p1, p2, b2Color(0.9f, 0.9f, 0.3f), 0.5f); } if (drawFrictionImpulse) { const b2Vec2 tangent = b2Cross(point->normal, 1.0f); const b2Vec2& p1 = point->position; const b2Vec2 p2 = p1 + k_impulseScale * point->tangentImpulse * tangent; DrawSegment(p1, p2, b2Color(0.9f, 0.9f, 0.3f)); } } for (int i = 0; i < _traceCount; ++i) { const TraceData* data = &_traceData[i]; DrawSegment(data->start, data->end, b2Color(0.9f, 0.0f, 0.0f)); DrawPoint(data->start, 0.2f, b2Color(0.0f, 0.95f, 0.3f)); DrawPoint(data->end, 0.2f, b2Color(0.3f, 0.7f, 0.0f)); } if (!_waterIntersectionPoints.empty()) DrawPolygon(&_waterIntersectionPoints[0], _waterIntersectionPoints.size(), b2Color(0.0f, 1.0f, 1.0f)); if (_enableTextureArray) glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); glPopMatrix(); GL_checkError(); if (_activeProgram != 0) GLContext::get().ctx_glUseProgram(_activeProgram); #endif }
//------------------------------------------------------------------------------ void DebugDraw::DrawPolygon( const b2Vec2 * vertices, int32 vertexCount, const b2Color & color ) { for ( int32 i = 0; i < vertexCount - 1; ++i ) { DrawSegment( vertices[i], vertices[i + 1], color ); } DrawSegment( vertices[vertexCount - 1], vertices[0], color ); }
void GLESDebugDraw::DrawTransform(const b2Transform& xf) { b2Vec2 p1 = xf.p, p2; const float32 k_axisScale = 0.4f; p2 = p1 + k_axisScale * xf.q.GetXAxis(); DrawSegment(p1, p2, b2Color(1,0,0)); p2 = p1 + k_axisScale * xf.q.GetYAxis(); DrawSegment(p1,p2,b2Color(0,1,0)); }
void DebugRenderer::DrawTransform (const b2Transform& xf) { const b2Vec2& p1 = xf.p; const float32 k_axisScale = 0.4f; const b2Vec2 p2 = p1 + k_axisScale * xf.q.GetXAxis(); DrawSegment(p1, p2, b2Color(1.0f, 0.0f, 0.0f)); const b2Vec2 p3 = p1 + k_axisScale * xf.q.GetYAxis(); DrawSegment(p1, p3, b2Color(0.0f, 1.0f, 0.0f)); }
void Render::DrawShape(b2Fixture* fixture, const b2Transform& xf, const b2Color& color) { switch (fixture->GetType()) { case b2Shape::e_circle: { b2CircleShape* circle = (b2CircleShape*) fixture->GetShape(); b2Vec2 center = b2Mul(xf, circle->m_p); float32 radius = circle->m_radius; b2Vec2 axis = b2Mul(xf.q, b2Vec2(1.0f, 0.0f)); DrawSolidCircle(center, radius, axis, color); } break; case b2Shape::e_edge: { b2EdgeShape* edge = (b2EdgeShape*) fixture->GetShape(); b2Vec2 v1 = b2Mul(xf, edge->m_vertex1); b2Vec2 v2 = b2Mul(xf, edge->m_vertex2); DrawSegment(v1, v2, color); } break; case b2Shape::e_chain: { b2ChainShape* chain = (b2ChainShape*) fixture->GetShape(); int32 count = chain->m_count; const b2Vec2* vertices = chain->m_vertices; b2Vec2 v1 = b2Mul(xf, vertices[0]); for (int32 i = 1; i < count; ++i) { b2Vec2 v2 = b2Mul(xf, vertices[i]); DrawSegment(v1, v2, color); DrawCircle(v1, 0.05f, color); v1 = v2; } } break; case b2Shape::e_polygon: { b2PolygonShape* poly = (b2PolygonShape*) fixture->GetShape(); int32 vertexCount = poly->m_vertexCount; b2Assert(vertexCount <= b2_maxPolygonVertices); b2Vec2 vertices[b2_maxPolygonVertices]; for (int32 i = 0; i < vertexCount; ++i) { vertices[i] = b2Mul(xf, poly->m_vertices[i]); } DrawSolidPolygon(vertices, vertexCount, color); } break; default: break; } }
void GLESDebugDraw::DrawTransform(const b2Transform& xf) { b2Vec2 p1 = xf.p, p2; const float32 k_axisScale = 0.4f; p2=b2Vec2(0,0); //p2 = p1 + k_axisScale * xf.R.col1; DrawSegment(p1,p2,b2Color(1,0,0)); //p2 = p1 + k_axisScale * xf.R.col2; DrawSegment(p1,p2,b2Color(0,1,0)); }
void EggAvatar::DrawCurve(IFTImage* pImage, int firstPoint, int numberPoints, bool shouldClose, UINT32 color) { for (int i = 1; i < numberPoints; ++i) { DrawSegment(pImage, firstPoint + i - 1, firstPoint + i, color); } if (shouldClose) { DrawSegment(pImage, firstPoint + numberPoints - 1, firstPoint, color); } }
void DrawTransform( const b2Transform &xf, const b2Colors &colors ) { b2Vec2 p1 = xf.position, p2; const float k_axisScale = 0.4f; p2 = p1 + k_axisScale * xf.R.col1; DrawSegment(p1,p2,colors[0]); p2 = p1 + k_axisScale * xf.R.col2; DrawSegment(p1,p2,colors[1]); }
void FrameBuffer::DrawCircle(float h, float k, float rx, float ry, unsigned int color, bool fill) { vector center(h, k, 0.0f); vector edge(rx, ry, 0.0f); float a = .01f; int steps = 360/a; vector oldEdge = edge; for (int i = 0; i < steps; i++) { edge.rotatePoint(center, vector(h,k,1.0f), a); DrawSegment(oldEdge, edge, color); if(fill)DrawSegment(center, edge, color); oldEdge = edge; } }
void CDebugDraw::DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) { for (int i=0;i<vertexCount;i++) { if (i < vertexCount-1) { DrawSegment(vertices[i],vertices[i+1],color); } else { DrawSegment(vertices[i],vertices[0],color); } } }
void DebugDraw::DrawForce(const b2Vec2& point, const b2Vec2& force, const b2Color& color) { const float32 k_forceScale = 0.1f; b2Vec2 p1 = point; b2Vec2 p2 = point + k_forceScale * force; DrawSegment(p1, p2, color); }
void GLESDebugDraw::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { const float32 k_segments = 16.0f; int vertexCount=16; const float32 k_increment = 2.0f * b2_pi / k_segments; float32 theta = 0.0f; GLfloat glVertices[vertexCount*2]; for (int32 i = 0; i < k_segments; ++i) { b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta)); glVertices[i*2]=v.x * mRatio; glVertices[i*2+1]=v.y * mRatio; theta += k_increment; } glUniform4f(shaderProgram->locationOfUniform("color"), color.r, color.g, color.b, 1.0); glVertexAttribPointer(shaderProgram->indexForAttribute("position"), 2, GL_FLOAT, 0, 0, glVertices); glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount); glDrawArrays(GL_LINE_LOOP, 0, vertexCount); // Draw the axis line DrawSegment(center,center+radius*axis,color); }
void GLESDebugDraw::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { const float32 k_segments = 16.0f; const int vertexCount=16; const float32 k_increment = 2.0f * b2_pi / k_segments; float32 theta = 0.0f; GLfloat glVertices[vertexCount*2]; for (int32 i = 0; i < k_segments; ++i) { b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta)); glVertices[i*2]=v.x; glVertices[i*2+1]=v.y; theta += k_increment; } glColor4f(color.r, color.g, color.b,0.5f); glVertexPointer(2, GL_FLOAT, 0, glVertices); glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount); glColor4f(color.r, color.g, color.b,1); glDrawArrays(GL_LINE_LOOP, 0, vertexCount); // Draw the axis line DrawSegment(center,center+radius*axis,color); }
void FXElectricity::Draw( void ) { float scale, incr = 0, detail = 0, tcStart = 0 , tcEnd = m_stScale; //Check for tapering if ( m_flags & FXF_TAPER ) { // This overrides the default of zero incr = m_scale / MAX_BOLT_SEGMENTS; } scale = m_scale; m_init = false; // Set up to calculate the texture coords so the texture can be mapped across the length of the bolt if ( m_flags & FXF_WRAP ) { detail = m_stScale / MAX_BOLT_SEGMENTS; } //Do all segments for ( int i = 0; i < MAX_BOLT_SEGMENTS - 1 ; i++ ) { if ( m_flags & FXF_WRAP ) { // This will override the defaults if necessary tcStart = detail * i; tcEnd = detail * (i+ 1); } scale -= incr; DrawSegment( m_boltVerts[i], m_boltVerts[i+1], scale, tcStart, tcEnd ); } }
void DebugRenderer::DrawSolidCircle (const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { #ifndef NO_DEBUG_RENDERER const float32 k_segments = 16.0f; const int vertexCount = 16; const float32 k_increment = 2.0f * b2_pi / k_segments; float32 theta = 0.0f; GLfloat glVertices[vertexCount * 2]; for (int i = 0; i < k_segments; ++i) { const b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta)); glVertices[i * 2] = v.x; glVertices[i * 2 + 1] = v.y; theta += k_increment; } setColorPointer(color, 0.5f, vertexCount); glVertexPointer(2, GL_FLOAT, 0, glVertices); glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount); setColorPointer(color, 1.0f, vertexCount); glDrawArrays(GL_LINE_LOOP, 0, vertexCount); GL_checkError(); // Draw the axis line DrawSegment(center, center + radius * axis, color); #endif }
void LHBox2dDebug::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { const float32 k_segments = 16.0f; int vertexCount=16; const float32 k_increment = 2.0f * b2_pi / k_segments; float32 theta = 0.0f; Vec2* vertices = new Vec2[vertexCount]; for (int32 i = 0; i < k_segments; ++i) { b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta)); vertices[i] = Vec2(v.x*mRatio, v.y*mRatio); theta += k_increment; } Color4F fillColor = Color4F(color.r, color.g, color.b, 0.5); Color4F borderColor = Color4F(color.r, color.g, color.b, 1); drawNode->drawPolygon(vertices, vertexCount, fillColor, 1, borderColor); delete[] vertices; // Draw the axis line DrawSegment(center,center+radius*axis,color); }
/* Initialize the drawing of a segment of type other than trace. */ DRAWSEGMENT* PCB_EDIT_FRAME::Begin_DrawSegment( DRAWSEGMENT* Segment, STROKE_T shape, wxDC* DC ) { int lineWidth; DRAWSEGMENT* DrawItem; lineWidth = GetDesignSettings().GetLineThickness( GetActiveLayer() ); if( Segment == NULL ) // Create new segment. { SetCurItem( Segment = new DRAWSEGMENT( GetBoard() ) ); Segment->SetFlags( IS_NEW ); Segment->SetLayer( GetActiveLayer() ); Segment->SetWidth( lineWidth ); Segment->SetShape( shape ); Segment->SetAngle( 900 ); Segment->SetStart( GetCrossHairPosition() ); Segment->SetEnd( GetCrossHairPosition() ); m_canvas->SetMouseCapture( DrawSegment, Abort_EditEdge ); } else { // The ending point coordinate Segment->m_End was updated by the function // DrawSegment() called on a move mouse event during the segment creation if( Segment->GetStart() != Segment->GetEnd() ) { if( Segment->GetShape() == S_SEGMENT ) { SaveCopyInUndoList( Segment, UR_NEW ); GetBoard()->Add( Segment ); OnModify(); Segment->ClearFlags(); Segment->Draw( m_canvas, DC, GR_OR ); DrawItem = Segment; SetCurItem( Segment = new DRAWSEGMENT( GetBoard() ) ); Segment->SetFlags( IS_NEW ); Segment->SetLayer( DrawItem->GetLayer() ); Segment->SetWidth( lineWidth ); Segment->SetShape( DrawItem->GetShape() ); Segment->SetType( DrawItem->GetType() ); Segment->SetAngle( DrawItem->GetAngle() ); Segment->SetStart( DrawItem->GetEnd() ); Segment->SetEnd( DrawItem->GetEnd() ); DrawSegment( m_canvas, DC, wxDefaultPosition, false ); } else { End_Edge( Segment, DC ); Segment = NULL; } } } return Segment; }
void LiquidFunDebugDraw::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { Renderer::getCurrent()->getDebugRenderer()->queueFilledCircle(center, radius, CIRCLE_SEGMENTS, b2ColorToRgba(color, 0x60)); Renderer::getCurrent()->getDebugRenderer()->queueCircle(center, radius, CIRCLE_SEGMENTS, b2ColorToRgba(color, 0xFF)); DrawSegment(center, center + radius * axis, color); }
//---------------------------- void CBezier::Draw( void ) { vec3_t pos, old_pos; float mu, mum1; float incr = 1.0f / BEZIER_RESOLUTION, tex = 1.0f, tc1, tc2; int i; VectorCopy( mOrigin1, old_pos ); mInit = false; //Signify a new batch for vert gluing // Calculate the texture coords so the texture can stretch along the whole bezier // if ( mFlags & FXF_WRAP ) // { // tex = m_stScale / 1.0f; // } float mum13, mu3, group1, group2; tc1 = 0.0f; for ( mu = incr; mu <= 1.0f; mu += incr ) { //Four point curve mum1 = 1 - mu; mum13 = mum1 * mum1 * mum1; mu3 = mu * mu * mu; group1 = 3 * mu * mum1 * mum1; group2 = 3 * mu * mu *mum1; for ( i = 0; i < 3; i++ ) { pos[i] = mum13 * mOrigin1[i] + group1 * mControl1[i] + group2 * mControl2[i] + mu3 * mOrigin2[i]; } // if ( m_flags & FXF_WRAP ) // { tc2 = mu * tex; // } // else // { // // Texture will get mapped onto each segement // tc1 = 0.0f; // tc2 = 1.0f; // } //Draw it DrawSegment( old_pos, pos, tc1, tc2 ); VectorCopy( pos, old_pos ); tc1 = tc2; } drawnFx++; mLines++; // NOT REALLY A LINE }
void Slice::Update(double dt) { if (touchId >= 0) { cpDataPointer data = this; DrawSegment(sliceStart, lastTouchPoint, RGBAColor(1, 0, 0, 1), data); } ChipmunkDemo::Update(dt); }
void FrameBuffer::Draw3DSegment(vector p0, vector p1, PPC *ppc, unsigned int color) { vector pp0, pp1; if (!ppc->Project(p0, pp0)) return; if (!ppc->Project(p1, pp1)) return; DrawSegment(pp0, pp1, color); }
void SimpleChimneyDraw::drawSegment( AcGiWorldDraw* mode, const AcGePoint3d& spt, const AcGePoint3d& ept ) { AcGeVector3d v = ept - spt; int n = ( int )( ( v.length() + m_space ) / ( m_length + m_space ) ); //acutPrintf(_T("\n可绘制的个数:%d"), n); v.normalize(); AcGePoint3d pt = spt; for( int i = 0; i < n; i++ ) { DrawSegment( mode, pt, v, m_length, m_width, m_lineWidth ); pt = pt + v * ( m_length + m_space ); } double ll = ( ept - pt ).length(); if( ll > m_length * 0.5 ) // 如果有长度的50%,则绘制一小段 { DrawSegment( mode, pt, v, ll, m_width, m_lineWidth ); } }
/* Actually draw histogram as a diagram, cause there's too much data */ static void DrawHistogramAsDiagram (int cy, int paint_width, int hist_count) { double step; int i; /* Rescale the graph every few moves (as opposed to every move) */ hist_count -= hist_count % 8; hist_count += 8; hist_count /= 2; step = (double) paint_width / (hist_count + 1); for( i=0; i<2; i++ ) { int index = currFirst; int side = (currCurrent + i + 1) & 1; /* Draw current side last */ double x = MarginX + MarginW; if( (index & 1) != side ) { x += step / 2; index++; } DrawSegment( (int) x, cy, NULL, NULL, PEN_NONE ); index += 2; while( index < currLast ) { x += step; DrawSeparator( index, (int) x ); /* Extend line up to current point */ if( currPvInfo[index].depth > 0 ) { DrawSegment((int) x, GetValueY( GetPvScore(index) ), NULL, NULL, (side==0 ? PEN_BOLDWHITE: PEN_BOLDBLACK) ); } index += 2; } } }
void DebugDraw::DrawSolidCircle(const b2Vec2& center,float32 radius,const b2Vec2& axis,const b2Color& color) { sf::CircleShape circle(converter::metersToPixels(radius),30); circle.setOrigin(converter::metersToPixels(radius),converter::metersToPixels(radius)); circle.setPosition(converter::metersToPixels(center.x),converter::metersToPixels(center.y)); circle.setFillColor(_b2ToSf(color,50)); circle.setOutlineThickness(1.0f); circle.setOutlineColor(_b2ToSf(color)); _render.draw(circle); b2Vec2 p = center + (radius * axis); DrawSegment(center,p,color); }
/// Draw a solid circle. void DebugRender::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) { cs.setFillColor(sf::Color(0,0,0,0)); cs.setOutlineColor(sf::Color(255.f/color.r, 255.f/color.g, 255.f/color.b)); cs.setOutlineThickness(2.f); cs.setPosition(center.x*pixelsPerMeter, center.y*pixelsPerMeter); cs.setRadius(radius*pixelsPerMeter); cs.setOrigin(radius*pixelsPerMeter, radius*pixelsPerMeter); window->draw(cs); b2Vec2 seg = center; seg.x += axis.x*radius; seg.y += axis.y*radius; DrawSegment(center, seg, color); }
void SCH_EDIT_FRAME::DeleteCurrentSegment( wxDC* DC ) { SCH_SCREEN* screen = GetScreen(); SetRepeatItem( NULL ); if( ( screen->GetCurItem() == NULL ) || !screen->GetCurItem()->IsNew() ) return; DrawSegment( m_canvas, DC, wxDefaultPosition, false ); screen->Remove( screen->GetCurItem() ); m_canvas->SetMouseCaptureCallback( NULL ); screen->SetCurItem( NULL ); }
void kwxLCDDisplay::DrawDigit( wxDC *dc, int digit, wxDigitData *data ) { unsigned char dec = Decode( data->value ); if( data->value == ':' ) //scrive : DrawTwoDots( dc, digit ); else { for( int c = 0; c < LCD_NUMBER_SEGMENTS - 1; c++ ) { DrawSegment( dc, digit, c, ( dec >> c ) & 1 ); } DrawSegment( dc, digit, 7, data->comma ); //scrive comma } }