void DrawTriangleFan(const RasterPoint *points, unsigned num_points) {
DrawPolygon(points, num_points);
}
MAGICK_NET_EXPORT void DrawingWand_Polygon(DrawingWand *instance, const PointInfo *coordinates, const size_t length, ExceptionInfo **exception)
{
DrawPolygon(instance, length, coordinates);
MAGICK_NET_SET_DRAW_EXCEPTION;
}
void RenderingCommandExecutor::Execute(
Graphics* graphics,
Effekseer::Manager* effectManager,
EffekseerRenderer::Renderer* effectRenderer,
SpriteRenderer3D* spriteRenerer3D,
std::vector<RenderingCommand*>& commands)
{
auto commands_ptr = commands.data();
auto commands_size = commands.size();
auto g = (Graphics_Imp*) graphics;
for (int32_t i = 0; i < commands_size; i++)
{
auto& command = commands_ptr[i];
if (command->GetType() == RenderingCommandType::Clear)
{
auto c = (RenderingCommand_Clear*) command;
g->Clear(c->IsColorTarget, c->IsDepthTarget, c->Color_);
}
else if (command->GetType() == RenderingCommandType::Draw)
{
auto c = (RenderingCommand_Draw*) command;
c->Shader->SetConstantValues(c->ConstantValues, c->ConstantValueCount);
g->SetVertexBuffer(c->VB);
g->SetIndexBuffer(c->IB);
g->SetShader(c->Shader);
g->SetRenderState(c->RS);
if (c->PolyOffset == 0)
{
g->DrawPolygon(c->PolyCount);
}
else
{
g->DrawPolygon(c->PolyOffset, c->PolyCount);
}
}
else if (command->GetType() == RenderingCommandType::DrawInstanced)
{
auto c = (RenderingCommand_DrawInstanced*) command;
c->Shader->SetConstantValues(c->ConstantValues, c->ConstantValueCount);
g->SetVertexBuffer(c->VB);
g->SetIndexBuffer(c->IB);
g->SetShader(c->Shader);
g->SetRenderState(c->RS);
g->DrawPolygonInstanced(c->PolyCount, c->InstanceCount);
}
else if (command->GetType() == RenderingCommandType::SetRenderTarget)
{
auto c = (RenderingCommand_SetRenderTarget*) command;
if (c->RenderTextures[1] == nullptr && c->RenderTextures[2] == nullptr && c->RenderTextures[2] == nullptr)
{
g->SetRenderTarget(
(RenderTexture2D_Imp*)c->RenderTextures[0],
c->Depth);
}
else
{
g->SetRenderTarget(
(RenderTexture2D_Imp*) c->RenderTextures[0],
(RenderTexture2D_Imp*) c->RenderTextures[1],
(RenderTexture2D_Imp*) c->RenderTextures[2],
(RenderTexture2D_Imp*) c->RenderTextures[3],
c->Depth);
}
}
else if (command->GetType() == RenderingCommandType::DrawEffect)
{
auto c = (RenderingCommand_DrawEffect*) command;
// 行列を転置して設定
Effekseer::Matrix44 cameraMat, projMat;
for (auto c_ = 0; c_ < 4; c_++)
{
for (auto r = 0; r < 4; r++)
{
cameraMat.Values[c_][r] = c->CameraMat.Values[r][c_];
projMat.Values[c_][r] = c->ProjMat.Values[r][c_];
}
}
effectRenderer->SetCameraMatrix(cameraMat);
effectRenderer->SetProjectionMatrix(projMat);
effectRenderer->BeginRendering();
effectManager->Draw();
effectRenderer->EndRendering();
// レンダー設定リセット
g->CommitRenderState(true);
}
else if (command->GetType() == RenderingCommandType::DrawSprite)
{
auto c = (RenderingCommand_DrawSprite*) command;
spriteRenerer3D->SetMatrixes(c->CameraMat, c->ProjMat);
spriteRenerer3D->DrawCache();
}
}
}
void CDX10Renderer::DrawPolygonFill(TVector2* _pPoints, int _iPoints, const bool _kHasBorder)
{
// Can't draw polygons... No triangle fan topology, no easy way to do it
DrawPolygon(_pPoints, _iPoints);
}
void DebugDraw::DrawSolidPolygon (const b2Vec2 *vertices, int32 vertexCount, const b2Color &color)
{
DrawPolygon( vertices, vertexCount, color);
//std::cout << "Drew Solid Polygon" << std::endl;
}
void DrawCircle(float x, float y, float r, bool fill, const Color * color) {
DrawPolygon(x, y, r, SMOOTH_FACTOR, 0, fill, color);
}
void VisitPolygon(const AirspacePolygon &airspace) {
if (SetupCanvas(airspace))
DrawPolygon(airspace.GetPoints());
}
// Draw a string in the specified font
void BaseEngine::DrawString(int iX, int iY, const char* pText,
unsigned int uiColour, Font* pFont, SDL_Surface* pTarget )
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( pFont == NULL )
pFont = g_pMainFont;
if ( m_bInsideDraw )
if (SDL_MUSTLOCK(m_pActualScreen))
SDL_UnlockSurface(m_pActualScreen);
SDL_Color color = { (uiColour&0xff0000)>>16, (uiColour&0xff00)>>8, (uiColour&0xff), 0 };
if ( ( pFont != NULL ) && ( pFont->GetFont() != NULL ) )
{
SDL_Surface *sText = TTF_RenderText_Solid( pFont->GetFont(), pText, color );
SDL_Rect rcDest = {iX,iY,0,0};
SDL_BlitSurface( sText, NULL, pTarget, &rcDest );
SDL_FreeSurface( sText );
}
if ( m_bInsideDraw )
if (SDL_MUSTLOCK(m_pActualScreen))
SDL_LockSurface(m_pActualScreen);
}
// Draw a triangle, as two vertical sided regions.
void BaseEngine::DrawTriangle(
double fX1, double fY1,
double fX2, double fY2,
double fX3, double fY3,
unsigned int uiColour,
SDL_Surface* pTarget )
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
// Ensure order is 1 2 3 from left to right
if ( fX1 > fX2 ) { Swap( fX1,fX2 ); Swap( fY1,fY2 ); } // Bigger of 1 and 2 is in position 2
if ( fX2 > fX3 ) { Swap( fX2,fX3 ); Swap( fY2,fY3 ); } // Bigger of new 2 and 3 is in position 3
if ( fX1 > fX2 ) { Swap( fX1,fX2 ); Swap( fY1,fY2 ); } // Bigger of 1 and new 2 is in position 2
if ( fX1 == fX2 )
DrawVerticalSidedRegion( fX1, fX3, fY1, fY3, fY2, fY3, uiColour, pTarget );
else if ( fX2 == fX3 )
DrawVerticalSidedRegion( fX1, fX3, fY1, fY2, fY1, fY3, uiColour, pTarget );
else
{
// Split into two triangles. Find position on line 1-3 to split at
double dSplitPointY = (double)fY1 +
( ( (double)((fX2-fX1)*(fY3-fY1)) )
/ (double)(fX3-fX1) );
DrawVerticalSidedRegion( fX1, fX2, fY1, fY2, fY1, dSplitPointY, uiColour, pTarget );
DrawVerticalSidedRegion( fX2, fX3, fY2, fY3, dSplitPointY, fY3, uiColour, pTarget );
}
}
// Draw a vertical sided region.
// If two points are the same then it is a triangle.
// To do an arbitrary triangle, just draw two next to each other, one for left and one for right.
void BaseEngine::DrawVerticalSidedRegion(
double fX1, double fX2,// X positions
double fY1a, double fY2a, // Start y positions for x1 and x2
double fY1b, double fY2b, // End y positions for x1 and x2
unsigned int uiColour,
SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
// Ensure X1< X2, otherwise steps will go wrong!
// Switch the points if x and y are wrong way round
if ( fX2< fX1 ) { Swap(fX1,fX2); Swap(fY1a,fY2a); Swap(fY1b,fY2b); }
int iXStart = (int)(fX1+0.5);
int iXEnd = (int)(fX2+0.5);
// If integer x positions are the same then avoid floating point inaccuracy problems by a special case
if ( iXStart == iXEnd )
{
int iYStart = (int)(fY1a+0.5);
int iYEnd = (int)(fY2a+0.5);
for ( int iY = iYStart ; iY<= iYEnd ; iY++ )
SafeSetPixel( iXStart, iY, uiColour, pTarget );
}
else
{
// Draw left hand side
int iYStart = (int)(fY1a+0.5);
int iYEnd = (int)(fY1b+0.5);
if ( iYStart> iYEnd ) Swap( iYStart, iYEnd );
//printf( "Firstline %d to %d (%f to %f)\n", iYStart, iYEnd, fY1a, fY1b );
for ( int iY = iYStart ; iY<= iYEnd ; iY++ )
SafeSetPixel( iXStart, iY, uiColour, pTarget );
// Draw the middle
for ( int iX = iXStart+1 ; iX< iXEnd ; iX++ )
{
double fYStart = fY1a + ( (((double)iX)-fX1)*(fY2a-fY1a)) /(fX2-fX1);
double fYEnd = fY1b + ((((double)iX)-fX1)*(fY2b-fY1b))/(fX2-fX1);
if ( fYEnd< fYStart ) Swap( fYStart, fYEnd );
int iYStart = (int)(fYStart+0.5);
int iYEnd = (int)(fYEnd+0.5);
//printf( "Line from %d to %d (%f to %f)\n", iYStart, iYEnd, fYStart, fYEnd );
for ( int iY = iYStart ; iY<= iYEnd ; iY++ )
SafeSetPixel( iX, iY, uiColour, pTarget );
}
// Draw right hand side
iYStart = (int)(fY2a+0.5);
iYEnd = (int)(fY2b+0.5);
if ( iYStart> iYEnd ) Swap( iYStart, iYEnd );
//printf( "Last line %d to %d (%f to %f)\n", iYStart, iYEnd, fY2a, fY2b );
for ( int iY = iYStart ; iY<= iYEnd ; iY++ )
SafeSetPixel( iXEnd, iY, uiColour, pTarget );
}
}
// Draw a rectangle on the specified surface
void BaseEngine::DrawRectangle(int iX1, int iY1, int iX2, int iY2,
unsigned int uiColour, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( iX2 < iX1 ) { int t = iX1; iX1 = iX2; iX2 = t; }
if ( iY2 < iY1 ) { int t = iY1; iY1 = iY2; iY2 = t; }
for ( int iX = iX1 ; iX <= iX2 ; iX++ )
for ( int iY = iY1 ; iY <= iY2 ; iY++ )
SafeSetPixel( iX, iY, uiColour, pTarget );
}
// Draw an oval on the specified surface
void BaseEngine::DrawOval(int iX1, int iY1, int iX2, int iY2,
unsigned int uiColour, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( iX2 < iX1 ) { int t = iX1; iX1 = iX2; iX2 = t; }
if ( iY2 < iY1 ) { int t = iY1; iY1 = iY2; iY2 = t; }
double fCentreX = ((double)(iX2+iX1))/2.0;
double fCentreY = ((double)(iY2+iY1))/2.0;
double fXFactor = (double)((iX2-iX1) * (iX2-iX1))/4.0;
double fYFactor = (double)((iY2-iY1) * (iY2-iY1))/4.0;
double fDist;
for ( int iX = iX1 ; iX <= iX2 ; iX++ )
for ( int iY = iY1 ; iY <= iY2 ; iY++ )
{
fDist = ((double)iX - fCentreX) * ((double)iX - fCentreX)/fXFactor
+ ((double)iY - fCentreY) * ((double)iY - fCentreY)/fYFactor;
if ( fDist <= 1.0 )
SafeSetPixel( iX, iY, uiColour, pTarget );
}
}
// Draw an oval on the specified surface
void BaseEngine::DrawHollowOval( int iX1, int iY1, int iX2, int iY2,
int iX3, int iY3, int iX4, int iY4,
unsigned int uiColour, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( iX2 < iX1 ) Swap( iX1, iX2 );
if ( iY2 < iY1 ) Swap( iY1, iY2 );
if ( iX4 < iX3 ) Swap( iX3, iX4 );
if ( iY4 < iY3 ) Swap( iY3, iY4 );
double fCentreX1 = ((double)(iX2+iX1))/2.0;
double fCentreY1 = ((double)(iY2+iY1))/2.0;
double fXFactor1 = (double)((iX2-iX1) * (iX2-iX1))/4.0;
double fYFactor1 = (double)((iY2-iY1) * (iY2-iY1))/4.0;
double fCentreX2 = ((double)(iX4+iX3))/2.0;
double fCentreY2 = ((double)(iY4+iY3))/2.0;
double fXFactor2 = (double)((iX4-iX3) * (iX4-iX3))/4.0;
double fYFactor2 = (double)((iY4-iY3) * (iY4-iY3))/4.0;
double fDist1, fDist2;
for ( int iX = iX1 ; iX <= iX2 ; iX++ )
for ( int iY = iY1 ; iY <= iY2 ; iY++ )
{
fDist1 = ((double)iX - fCentreX1) * ((double)iX - fCentreX1)/fXFactor1
+ ((double)iY - fCentreY1) * ((double)iY - fCentreY1)/fYFactor1;
fDist2 = ((double)iX - fCentreX2) * ((double)iX - fCentreX2)/fXFactor2
+ ((double)iY - fCentreY2) * ((double)iY - fCentreY2)/fYFactor2;
if ( ( fDist1 <= 1.0 ) && ( fDist2 >= 1.0 ) )
SafeSetPixel( iX, iY, uiColour, pTarget );
}
}
// Draw a line on the specified surface
void BaseEngine::DrawLine(double fX1, double fY1, double fX2, double fY2,
unsigned int uiColour, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
int iX1 = (int)(fX1+0.5);
int iX2 = (int)(fX2+0.5);
int iY1 = (int)(fY1+0.5);
int iY2 = (int)(fY2+0.5);
int iSteps = (iX2-iX1);
if ( iSteps < 0 ) iSteps = -iSteps;
if ( iY2 > iY1 ) iSteps += (iY2-iY1); else iSteps += (iY1-iY2);
iSteps+=2;
double fXStep = ((double)(fX2-fX1))/iSteps;
double fYStep = ((double)(fY2-fY1))/iSteps;
for ( int i = 0 ; i <= iSteps ; i++ )
{
SafeSetPixel( (int)(0.5 + fX1 + fXStep*i), (int)(0.5 + fY1 + fYStep*i), uiColour, pTarget );
}
}
// Draw a thick line on the specified surface
void BaseEngine::DrawThickLine( double fX1, double fY1, double fX2, double fY2,
unsigned int uiColour, int iThickness, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( iThickness < 2 )
{ // Go to the quicker draw function
DrawLine(fX1, fY1, fX2, fY2, uiColour, pTarget);
return;
}
double fAngle1 = GetAngle( fX1, fY1, fX2, fY2 );
double fAngle1a = fAngle1 - ((5 * M_PI) / 4.0);
double fAngle1b = fAngle1 + ((5 * M_PI) / 4.0);
double fRectX1 = fX1 + iThickness * cos(fAngle1a) * 0.5;
double fRectY1 = fY1 + iThickness * sin(fAngle1a) * 0.5;
double fRectX2 = fX1 + iThickness * cos(fAngle1b) * 0.5;
double fRectY2 = fY1 + iThickness * sin(fAngle1b) * 0.5;
double fAngle2 = fAngle1 + M_PI;
double fAngle2a = fAngle2 - ((5 * M_PI) / 4.0);
double fAngle2b = fAngle2 + ((5 * M_PI) / 4.0);
double fRectX3 = fX2 + iThickness * cos(fAngle2a) * 0.5;
double fRectY3 = fY2 + iThickness * sin(fAngle2a) * 0.5;
double fRectX4 = fX2 + iThickness * cos(fAngle2b) * 0.5;
double fRectY4 = fY2 + iThickness * sin(fAngle2b) * 0.5;
DrawTriangle( fRectX1, fRectY1, fRectX2, fRectY2, fRectX3, fRectY3, uiColour, pTarget );
DrawTriangle( fRectX3, fRectY3, fRectX4, fRectY4, fRectX1, fRectY1, uiColour, pTarget );
}
// Draw a polygon on the specified surface
void BaseEngine::DrawPolygon(
int iPoints, double* pXArray, double* pYArray,
unsigned int uiColour, SDL_Surface* pTarget)
{
if ( pTarget == NULL )
pTarget = m_pActualScreen;
if ( iPoints == 1 )
{
SafeSetPixel( pXArray[0], pYArray[0], uiColour, pTarget );
return;
}
if ( iPoints == 2 )
{
DrawLine( pXArray[0], pYArray[0], pXArray[1], pYArray[1], uiColour, pTarget );
return;
}
/* if ( iPoints == 3 )
{
printf( "Draw triangle for points 0, 1, 2 of %d available\n", iPoints );
DrawTriangle( pXArray[0], pYArray[0], pXArray[1], pYArray[1], pXArray[2], pYArray[2],
uiColour, pTarget );
return;
}
*/
// Otherwise attempt to eliminate a point by filling the polygon, then call this again
double fXCentre, fYCentre; //fX1, fX2, fX3, fY1, fY2, fY3;
int i2, i3;
double fAngle1, fAngle2, fAngle3;
for ( int i1 = 0 ; i1 < iPoints ; i1++ )
{
i2 = i1 + 1; if ( i2 >= iPoints ) i2 -= iPoints;
i3 = i1 + 2; if ( i3 >= iPoints ) i3 -= iPoints;
fXCentre = (pXArray[i1] + pXArray[i2] + pXArray[i3]) / 3.0;
fYCentre = (pYArray[i1] + pYArray[i2] + pYArray[i3]) / 3.0;
fAngle1 = GetAngle( fXCentre, fYCentre, pXArray[i1], pYArray[i1] );
fAngle2 = GetAngle( fXCentre, fYCentre, pXArray[i2], pYArray[i2] );
fAngle3 = GetAngle( fXCentre, fYCentre, pXArray[i3], pYArray[i3] );
// Now work out the relative angle positions and make sure all are positive
fAngle2 -= fAngle1; if ( fAngle2 < 0 ) fAngle2 += 2*M_PI;
fAngle3 -= fAngle1; if ( fAngle3 < 0 ) fAngle3 += 2*M_PI;
if ( fAngle2 < fAngle3 )
{ // Then points are in clockwise order so central one can be eliminated as long as we don't
// fill an area that we shouldn't
bool bPointIsWithinTriangle = false;
if ( iPoints > 3 )
{ // Need to check that there isn't a point within the area - for convex shapes
double fLineAngle12 = GetAngle( pXArray[i1], pYArray[i1], pXArray[i2], pYArray[i2] );
if ( fLineAngle12 < 0 )
fLineAngle12 += M_PI * 2.0;
double fLineAngle23 = GetAngle( pXArray[i2], pYArray[i2], pXArray[i3], pYArray[i3] );
if ( fLineAngle23 < 0 )
fLineAngle23 += M_PI * 2.0;
double fLineAngle31 = GetAngle( pXArray[i3], pYArray[i3], pXArray[i1], pYArray[i1] );
if ( fLineAngle31 < 0 )
fLineAngle31 += M_PI * 2.0;
for ( int i = i3+1 ; i != i1 ; i++ )
{
if ( i >= iPoints )
{
i = 0;
if ( i1 == 0 )
break; // From the for loop - finished
}
// Otherwise we need to work out whether point i is to right of line i3 to i1
double fPointAngle1 = GetAngle( pXArray[i1], pYArray[i1], pXArray[i], pYArray[i] );
if ( fPointAngle1 < 0 )
fPointAngle1 += M_PI * 2.0;
fPointAngle1 -= fLineAngle12;
if ( fPointAngle1 < 0 )
fPointAngle1 += M_PI * 2.0;
double fPointAngle2 = GetAngle( pXArray[i2], pYArray[i2], pXArray[i], pYArray[i] );
if ( fPointAngle2 < 0 )
fPointAngle2 += M_PI * 2.0;
fPointAngle2 -= fLineAngle23;
if ( fPointAngle2 < 0 )
fPointAngle2 += M_PI * 2.0;
double fPointAngle3 = GetAngle( pXArray[i3], pYArray[i3], pXArray[i], pYArray[i] );
if ( fPointAngle3 < 0 )
fPointAngle3 += M_PI * 2.0;
fPointAngle3 -= fLineAngle31;
if ( fPointAngle3 < 0 )
fPointAngle3 += M_PI * 2.0;
if ( ( fPointAngle1 < M_PI ) && ( fPointAngle2 < M_PI ) && ( fPointAngle3 < M_PI ) )
bPointIsWithinTriangle = true;
}
}
if ( !bPointIsWithinTriangle )
{// If not then try the next position
printf( "Draw for points %d, %d, %d of %d available\n", i1, i2, i3, iPoints );
DrawTriangle( pXArray[i1], pYArray[i1], pXArray[i2], pYArray[i2],
pXArray[i3], pYArray[i3], /*GetColour(iPoints)*/uiColour, pTarget );
// Remove the point i2 and then recurse
for ( int i = i2 ; i < (iPoints-1) ; i++ )
{
printf( "\tCopy point %d to %d\n", i+1, i );
pXArray[i] = pXArray[i+1];
pYArray[i] = pYArray[i+1];
}
if ( iPoints > 3 )
DrawPolygon( iPoints - 1, pXArray, pYArray, uiColour, pTarget );
return; // Done
}
}
}
}
void draw_object(Canvas *canvas, Quark *q)
{
VPoint anchor;
DObject *o = object_get_data(q);
if (o == NULL) {
return;
}
if (Apoint2Vpoint(q, &o->ap, &anchor) != RETURN_SUCCESS) {
return;
}
anchor.x += o->offset.x;
anchor.y += o->offset.y;
setclipping(canvas, FALSE);
activate_bbox(canvas, BBOX_TYPE_TEMP, TRUE);
reset_bbox(canvas, BBOX_TYPE_TEMP);
switch (o->type) {
case DO_LINE:
{
DOLineData *l = (DOLineData *) o->odata;
VPoint vp1;
double x, y, co, si;
x = l->vector.x;
y = l->vector.y;
co = cos(M_PI/180.0*o->angle);
si = sin(M_PI/180.0*o->angle);
vp1.x = anchor.x + x*co - y*si;
vp1.y = anchor.y + x*si + y*co;
setline(canvas, &o->line);
DrawLine(canvas, &anchor, &vp1);
switch (l->arrow_end) {
case ARROW_AT_NONE:
break;
case ARROW_AT_BEGINNING:
draw_arrowhead(canvas, &vp1, &anchor, &l->arrow,
&o->line.pen, &o->fillpen);
break;
case ARROW_AT_END:
draw_arrowhead(canvas, &anchor, &vp1, &l->arrow,
&o->line.pen, &o->fillpen);
break;
case ARROW_AT_BOTH:
draw_arrowhead(canvas, &vp1, &anchor, &l->arrow,
&o->line.pen, &o->fillpen);
draw_arrowhead(canvas, &anchor, &vp1, &l->arrow,
&o->line.pen, &o->fillpen);
break;
}
}
break;
case DO_BOX:
{
DOBoxData *b = (DOBoxData *) o->odata;
if (o->angle == 0.0) {
VPoint vp1, vp2;
vp1.x = anchor.x - b->width/2;
vp2.x = anchor.x + b->width/2;
vp1.y = anchor.y - b->height/2;
vp2.y = anchor.y + b->height/2;
setpen(canvas, &o->fillpen);
DrawFilledRect(canvas, &vp1, &vp2);
setline(canvas, &o->line);
DrawRect(canvas, &vp1, &vp2);
} else {
VPoint vps[4];
double x, y, co, si;
x = b->width/2;
y = b->height/2;
co = cos(M_PI/180.0*o->angle);
si = sin(M_PI/180.0*o->angle);
vps[0].x = anchor.x + x*co - y*si;
vps[0].y = anchor.y + x*si + y*co;
vps[1].x = anchor.x - x*co - y*si;
vps[1].y = anchor.y - x*si + y*co;
vps[2].x = anchor.x - x*co + y*si;
vps[2].y = anchor.y - x*si - y*co;
vps[3].x = anchor.x + x*co + y*si;
vps[3].y = anchor.y + x*si - y*co;
setpen(canvas, &o->fillpen);
DrawPolygon(canvas, vps, 4);
setline(canvas, &o->line);
DrawPolyline(canvas, vps, 4, POLYLINE_CLOSED);
}
}
break;
case DO_ARC:
{
VPoint vp1, vp2;
DOArcData *e = (DOArcData *) o->odata;
vp1.x = anchor.x - e->width/2;
vp2.x = anchor.x + e->width/2;
vp1.y = anchor.y - e->height/2;
vp2.y = anchor.y + e->height/2;
setpen(canvas, &o->fillpen);
/* FIXME: implement true ellipse rotation! */
DrawFilledArc(canvas, &vp1, &vp2, e->angle1 + o->angle, e->angle2,
e->closure_type);
setline(canvas, &o->line);
DrawArc(canvas, &vp1, &vp2, e->angle1 + o->angle, e->angle2,
e->closure_type, e->draw_closure);
}
break;
case DO_NONE:
break;
}
get_bbox(canvas, BBOX_TYPE_TEMP, &o->bb);
}
cpBool Buoyancy::WaterPreSolve(cpArbiter *arb, cpSpace *space, void *ptr)
{
CP_ARBITER_GET_SHAPES(arb, water, poly);
cpBody *body = cpShapeGetBody(poly);
// Get the top of the water sensor bounding box to use as the water level.
cpFloat level = cpShapeGetBB(water).t;
// Clip the polygon against the water level
int count = cpPolyShapeGetCount(poly);
int clippedCount = 0;
#ifdef _MSC_VER
// MSVC is pretty much the only compiler in existence that doesn't support variable sized arrays.
cpVect clipped[10];
#else
cpVect clipped[count + 1];
#endif
for(int i=0, j=count-1; i<count; j=i, i++){
cpVect a = cpBodyLocalToWorld(body, cpPolyShapeGetVert(poly, j));
cpVect b = cpBodyLocalToWorld(body, cpPolyShapeGetVert(poly, i));
if(a.y < level){
clipped[clippedCount] = a;
clippedCount++;
}
cpFloat a_level = a.y - level;
cpFloat b_level = b.y - level;
if(a_level*b_level < 0.0f){
cpFloat t = cpfabs(a_level)/(cpfabs(a_level) + cpfabs(b_level));
clipped[clippedCount] = cpvlerp(a, b, t);
clippedCount++;
}
}
// Calculate buoyancy from the clipped polygon area
cpFloat clippedArea = cpAreaForPoly(clippedCount, clipped, 0.0f);
cpFloat displacedMass = clippedArea*FLUID_DENSITY;
cpVect centroid = cpCentroidForPoly(clippedCount, clipped);
cpDataPointer data = ptr;
DrawPolygon(clippedCount, clipped, 0.0f, RGBAColor(0, 0, 1, 1), RGBAColor(0, 0, 1, 0.1f), data);
DrawDot(5, centroid, RGBAColor(0, 0, 1, 1), data);
cpFloat dt = cpSpaceGetCurrentTimeStep(space);
cpVect g = cpSpaceGetGravity(space);
// Apply the buoyancy force as an impulse.
cpBodyApplyImpulseAtWorldPoint(body, cpvmult(g, -displacedMass*dt), centroid);
// Apply linear damping for the fluid drag.
cpVect v_centroid = cpBodyGetVelocityAtWorldPoint(body, centroid);
cpFloat k = k_scalar_body(body, centroid, cpvnormalize(v_centroid));
cpFloat damping = clippedArea*FLUID_DRAG*FLUID_DENSITY;
cpFloat v_coef = cpfexp(-damping*dt*k); // linear drag
// cpFloat v_coef = 1.0/(1.0 + damping*dt*cpvlength(v_centroid)*k); // quadratic drag
cpBodyApplyImpulseAtWorldPoint(body, cpvmult(cpvsub(cpvmult(v_centroid, v_coef), v_centroid), 1.0/k), centroid);
// Apply angular damping for the fluid drag.
cpVect cog = cpBodyLocalToWorld(body, cpBodyGetCenterOfGravity(body));
cpFloat w_damping = cpMomentForPoly(FLUID_DRAG*FLUID_DENSITY*clippedArea, clippedCount, clipped, cpvneg(cog), 0.0f);
cpBodySetAngularVelocity(body, cpBodyGetAngularVelocity(body)*cpfexp(-w_damping*dt/cpBodyGetMoment(body)));
return cpTrue;
}
// Rendering entrance function
void MeshModelRender::DrawModel()
{
// set the default material here.
m_DefaultMaterial.SetMaterial();
Utility util;
// Whether show axis
if(util.IsSetFlag(m_State, RENDER_MODEL_AXIS))
DrawAxis();
// Whether show bounding box
if(util.IsSetFlag(m_State, RENDER_MODEL_BOUNDING_BOX))
DrawBoundingBox();
// Whether lighting
if(util.IsSetFlag(m_State, RENDER_MODEL_LIGHTING))
glEnable(GL_LIGHTING);
else
glDisable(GL_LIGHTING);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
// Whether per-element color
if(util.IsSetFlag(m_State, RENDER_MODEL_COLOR))
{
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
}
else
glDisable(GL_COLOR_MATERIAL);
switch(m_Mode) {
case RENDER_MODEL_VERTICES:
DrawModelDepth();
DrawModelVertices();
break;
case RENDER_MODEL_WIREFRAME:
DrawModelDepth();
DrawModelWireframe();
break;
case RENDER_MODEL_SOLID_FLAT:
DrawModelSolidFlat();
break;
case RENDER_MODEL_SOLID_SMOOTH:
DrawModelSolidSmooth();
break;
case RENDER_MODEL_SOLID_WITH_SHARPNESS:
DrawModelSolidWithSharpness();
break;
case RENDER_MODEL_SOLID_AND_WIREFRAME:
DrawModelSolidAndWireframe();
break;
case RENDER_MODEL_HIGHLIGHT_ONLY:
DrawModelHighlightOnly();
break;
case RENDER_MODEL_TEXTURE_MAPPING:
DrawModelTextureMapping();
break;
case RENDER_MODEL_VERTEX_COLOR:
DrawModelVertexColor();
break;
case RENDER_MODEL_FACE_COLOR:
DrawModelFaceColor();
break;
case RENDER_MODEL_TRANSPARENT:
DrawModelTransparent();
break;
case RENDER_MODEL_PARAM_TEXTURE:
DrawModelFaceTexture();
break;
}
glDisable(GL_LIGHTING);
if(util.IsSetFlag(m_State, RENDER_MODEL_POINT))
DrawPoint();
if(util.IsSetFlag(m_State, RENDER_MODEL_LINE))
DrawLine();
if(util.IsSetFlag(m_State, RENDER_MODEL_POLYGON))
DrawPolygon();
// draw kmax and kmin here.
if(util.IsSetFlag(m_State, RENDER_MODEL_KMAX_CURVATURE)
|| util.IsSetFlag(m_State, RENDER_MODEL_KMIN_CURVATURE))
{
DrawMeshCurvature(m_State);
}
glEnable(GL_LIGHTING);
}
void Draw::DrawPolygon(const Vector<Point>& vertices,
Color color, int width, Color outline, uint64 pattern, Color doxor)
{
DrawPolygon(vertices.Begin(), vertices.GetCount(), color, width, outline, pattern, doxor);
}
void DrawRegion( Region key, float scale ) {
if ( key == NULL ) return;
int stable = key->stable;
char name[256];
sprintf(name,"/tmp/T%03d.ppm",stable);
Image out = ReadPPMFile(name);
static int count = 0;
if ( !ImageIsGood(out) ) {
out = ConvertImage1(CopyImage(key->image));
sprintf(name,"/tmp/R%05d.ppm",count++);
} else sprintf(name,"/tmp/T%03d.ppm",stable);
fprintf(stderr,".");
int rv = RandomNumber(0,255);
int gv = RandomNumber(0,rv);
int bv = RandomNumber(0,gv);
int color = PIX3(rv,gv,bv);
DrawPolygon(key->border,out,color);
Ellipse e1 = NewEllipse(key->row,key->col,key->maj*scale,key->min*scale,key->phi);
DrawEllipse(e1,out,color); free(e1);
Image patch = CreateImage(41*sqrt(2),41*sqrt(2));
RegionToPatch(key,key->image,patch,scale);
FVec hist = GenerateOrientationHistogram(patch);
GaussianBlur1D(hist->values,hist->l,hist->r,2);
DrawFVec(hist,10,10,200,400,PIX3(0,0,250),out);
FVecFree(hist);
if ( PolygonIsGood(key->sizes) ) {
struct PointSt p1 = key->sizes->vertices[0];
struct PointSt p2 = key->sizes->vertices[key->sizes->numberOfVertices-1];
int i;
hist = FVecNew(0,255);
Point p;
while ( ( p = NextPolygonVertex(key->sizes) ) != NULL ) FVecSetAt(hist,p->y,p->x);
if ( p1.y < p2.y ) {
for(i=p1.y;i<=p2.y;i++) if ( hist->values[i] == 0.0 ) FVecAddAt(hist,i,1);
} else {
for(i=p2.y;i>=p1.y;i--) if ( hist->values[i] == 0.0 ) FVecAddAt(hist,i,1);
}
hist->l = MIN(p1.y,p2.y);
hist->r = MAX(p2.y-1,p1.y-1);
DrawSizeFVec(hist,497,0,1021,1023,color,stable,out);
DrawSizeFVec(hist,498,0,1022,1023,color,stable,out);
DrawSizeFVec(hist,499,0,1023,1023,color,stable,out);
}
WritePPM(name,out);
FreeImage(out);
}
void DrawTriangleFan(const BulkPixelPoint *points, unsigned num_points) {
DrawPolygon(points, num_points);
}
void wxSVGCanvas::RenderElement(wxSVGElement* elem, const wxSVGRect* rect, const wxSVGMatrix* parentMatrix,
const wxCSSStyleDeclaration* parentStyle, wxSVGSVGElement* ownerSVGElement, wxSVGElement* viewportElement,
wxProgressDialog* progressDlg) {
wxSVGMatrix matrix(*parentMatrix);
wxCSSStyleRef style(*parentStyle);
elem->SetOwnerSVGElement(ownerSVGElement);
elem->SetViewportElement(viewportElement);
switch (elem->GetDtd()) {
case wxSVG_SVG_ELEMENT: {
wxSVGSVGElement* element = (wxSVGSVGElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
if (element->GetWidth().GetAnimVal().GetUnitType() == wxSVG_LENGTHTYPE_UNKNOWN)
((wxSVGAnimatedLength&) element->GetWidth()).SetAnimVal( wxSVGLength(wxSVG_LENGTHTYPE_PERCENTAGE, 100));
if (element->GetHeight().GetAnimVal().GetUnitType() == wxSVG_LENGTHTYPE_UNKNOWN)
((wxSVGAnimatedLength&) element->GetHeight()).SetAnimVal( wxSVGLength(wxSVG_LENGTHTYPE_PERCENTAGE, 100));
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
if (rect && element->GetParent()) {
wxSVGRect rect2 = *rect;
wxSVGElement* parent = (wxSVGElement*) element->GetParent();
wxSVGTransformable* transformable = wxSVGTransformable::GetSVGTransformable(*parent);
if (transformable)
rect2 = rect2.MatrixTransform(transformable->GetCTM().Inverse());
RenderChilds(elem, &rect2, &matrix, &style, element, element, progressDlg);
} else
RenderChilds(elem, rect, &matrix, &style, element, element, progressDlg);
break;
}
case wxSVG_G_ELEMENT: {
wxSVGGElement* element = (wxSVGGElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
RenderChilds(elem, rect, &matrix, &style, ownerSVGElement, viewportElement, progressDlg);
break;
}
case wxSVG_LINE_ELEMENT: {
wxSVGLineElement* element = (wxSVGLineElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawLine(element, &matrix, &style);
break;
}
case wxSVG_POLYLINE_ELEMENT: {
wxSVGPolylineElement* element = (wxSVGPolylineElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawPolyline(element, &matrix, &style);
break;
}
case wxSVG_POLYGON_ELEMENT: {
wxSVGPolygonElement* element = (wxSVGPolygonElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawPolygon(element, &matrix, &style);
break;
}
case wxSVG_RECT_ELEMENT: {
wxSVGRectElement* element = (wxSVGRectElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawRect(element, &matrix, &style);
break;
}
case wxSVG_CIRCLE_ELEMENT: {
wxSVGCircleElement* element = (wxSVGCircleElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawCircle(element, &matrix, &style);
break;
}
case wxSVG_ELLIPSE_ELEMENT: {
wxSVGEllipseElement* element = (wxSVGEllipseElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawEllipse(element, &matrix, &style);
break;
}
case wxSVG_PATH_ELEMENT: {
wxSVGPathElement* element = (wxSVGPathElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawPath(element, &matrix, &style);
break;
}
case wxSVG_TSPAN_ELEMENT:
break;
case wxSVG_TEXT_ELEMENT: {
wxSVGTextElement* element = (wxSVGTextElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawText(element, &matrix, &style);
break;
}
case wxSVG_IMAGE_ELEMENT: {
wxSVGImageElement* element = (wxSVGImageElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN || element->GetOpacity() == 0)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
DrawImage(element, &matrix, &style, rect, progressDlg);
break;
}
case wxSVG_VIDEO_ELEMENT: {
wxSVGVideoElement* element = (wxSVGVideoElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN || element->GetOpacity() == 0)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
#ifdef USE_LIBAV
DrawVideo(element, &matrix, &style);
#else
wxSVGGElement* gElem = new wxSVGGElement();
gElem->SetOwnerSVGElement(ownerSVGElement);
gElem->SetViewportElement(viewportElement);
gElem->SetStyle(element->GetStyle());
wxSVGRectElement* rectElem = new wxSVGRectElement();
rectElem->SetX(element->GetX().GetAnimVal());
rectElem->SetY(element->GetY().GetAnimVal());
rectElem->SetWidth(element->GetWidth().GetAnimVal());
rectElem->SetHeight(element->GetHeight().GetAnimVal());
rectElem->SetFill(wxSVGPaint(0,0,0));
gElem->AppendChild(rectElem);
wxSVGTextElement* textElem = new wxSVGTextElement;
textElem->SetX((double)element->GetX().GetAnimVal());
textElem->SetY(element->GetY().GetAnimVal()+(double)element->GetHeight().GetAnimVal()/10);
textElem->SetFontSize((double)element->GetHeight().GetAnimVal()/15);
textElem->SetFill(wxSVGPaint(255,255,255));
textElem->SetStroke(wxSVGPaint(255,255,255));
textElem->AddChild(new wxSvgXmlNode(wxSVGXML_TEXT_NODE, wxT(""), wxT(" [") + element->GetHref() + wxT("]")));
gElem->AppendChild(textElem);
// render
RenderElement(gElem, rect, &matrix, &style, ownerSVGElement, viewportElement, progressDlg);
// delete shadow tree
delete gElem;
#endif
break;
}
case wxSVG_USE_ELEMENT: {
wxSVGUseElement* element = (wxSVGUseElement*) elem;
if (element->GetVisibility() == wxCSS_VALUE_HIDDEN)
break;
element->UpdateMatrix(matrix);
style.Add(element->GetStyle());
style.Add(element->GetAnimStyle());
// test if visible
if (element->GetWidth().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN
&& element->GetHeight().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN) {
if (rect && !ownerSVGElement->CheckIntersection(*elem, *rect))
break;
wxSVGPoint point(element->GetX().GetAnimVal() + element->GetWidth().GetAnimVal(),
element->GetY().GetAnimVal() + element->GetHeight().GetAnimVal());
point = point.MatrixTransform(matrix);
if (point.GetX() < 0 || point.GetY() < 0)
break;
}
// get ref element
wxString href = element->GetHref();
if (href.length() == 0 || href.GetChar(0) != wxT('#'))
break;
href.Remove(0, 1);
wxSVGElement* refElem = (wxSVGElement*) ownerSVGElement->GetElementById(href);
if (!refElem)
break;
// create shadow tree
wxSVGGElement* gElem = new wxSVGGElement();
gElem->SetOwnerDocument(elem->GetOwnerDocument());
gElem->SetOwnerSVGElement(ownerSVGElement);
gElem->SetViewportElement(viewportElement);
gElem->SetStyle(element->GetStyle());
if (element->GetX().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
gElem->Translate(element->GetX().GetAnimVal(), element->GetY().GetAnimVal());
if (refElem->GetDtd() == wxSVG_SYMBOL_ELEMENT || refElem->GetDtd() == wxSVG_SVG_ELEMENT) {
wxSVGSVGElement* svgElem;
if (refElem->GetDtd() == wxSVG_SVG_ELEMENT)
svgElem = (wxSVGSVGElement*) refElem->CloneNode();
else {
svgElem = new wxSVGSVGElement();
wxSvgXmlElement* child = refElem->GetChildren();
while (child) {
svgElem->AddChild(child->CloneNode());
child = child->GetNext();
}
svgElem->SetViewBox(((wxSVGSymbolElement*) refElem)->GetViewBox());
svgElem->SetPreserveAspectRatio(((wxSVGSymbolElement*) refElem)->GetPreserveAspectRatio());
}
if (element->GetWidth().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
svgElem->SetWidth(element->GetWidth().GetAnimVal());
if (element->GetHeight().GetAnimVal().GetUnitType() != wxSVG_LENGTHTYPE_UNKNOWN)
svgElem->SetHeight(element->GetHeight().GetAnimVal());
gElem->AddChild(svgElem);
LoadImages(refElem, svgElem, progressDlg);
} else
gElem->AddChild(refElem->CloneNode());
// render
RenderElement(gElem, rect, &matrix, &style, ownerSVGElement, viewportElement, progressDlg);
// delete shadow tree
delete gElem;
break;
}
default:
break;
}
}
static void
ParseDrawFunction(DviWidget dw, char *buf)
{
int v[DRAW_ARGS_MAX];
int i, no_move = 0;
char *ptr;
v[0] = v[1] = v[2] = v[3] = 0;
if (buf[0] == '\0')
return;
ptr = buf+1;
for (i = 0; i < DRAW_ARGS_MAX; i++) {
if (sscanf(ptr, "%d", v + i) != 1)
break;
while (*ptr == ' ')
ptr++;
while (*ptr != '\0' && *ptr != ' ')
ptr++;
}
switch (buf[0]) {
case 'l': /* draw a line */
DrawLine(dw, v[0], v[1]);
break;
case 'c': /* circle */
DrawCircle(dw, v[0]);
break;
case 'C':
DrawFilledCircle(dw, v[0]);
break;
case 'e': /* ellipse */
DrawEllipse(dw, v[0], v[1]);
break;
case 'E':
DrawFilledEllipse(dw, v[0], v[1]);
break;
case 'a': /* arc */
DrawArc(dw, v[0], v[1], v[2], v[3]);
break;
case 'p':
DrawPolygon(dw, v, i);
break;
case 'P':
DrawFilledPolygon(dw, v, i);
break;
case '~': /* wiggly line */
DrawSpline(dw, v, i);
break;
case 't':
dw->dvi.line_thickness = v[0];
break;
case 'f':
if (i > 0 && v[0] >= 0 && v[0] <= DVI_FILL_MAX)
dw->dvi.fill = v[0];
no_move = 1;
break;
default:
#if 0
warning("unknown drawing function %s", buf);
#endif
no_move = 1;
break;
}
if (!no_move) {
if (buf[0] == 'e') {
if (i > 0)
dw->dvi.state->x += v[0];
}
else {
while (--i >= 0) {
if (i & 1)
dw->dvi.state->y += v[i];
else
dw->dvi.state->x += v[i];
}
}
}
}
void
TerrainXSRenderer::Draw(Canvas &canvas, const ChartRenderer &chart, const short *elevations) const
{
const fixed max_distance = chart.GetXMax();
StaticArray<RasterPoint, CrossSectionRenderer::NUM_SLICES + 2> points;
canvas.SelectNullPen();
RasterBuffer::TerrainType last_type = RasterBuffer::TerrainType::UNKNOWN;
fixed last_distance = fixed(0);
for (unsigned j = 0; j < CrossSectionRenderer::NUM_SLICES; ++j) {
const fixed distance_factor =
fixed(j) / (CrossSectionRenderer::NUM_SLICES - 1);
const fixed distance = distance_factor * max_distance;
short h = elevations[j];
RasterBuffer::TerrainType type = RasterBuffer::GetTerrainType(h);
if (type == RasterBuffer::TerrainType::WATER)
h = 0;
// Close and paint polygon
if (j != 0 &&
type != last_type &&
last_type != RasterBuffer::TerrainType::UNKNOWN) {
const fixed center_distance = (distance + last_distance) / 2;
points.append() = chart.ToScreen(center_distance, fixed(0));
points.append() = chart.ToScreen(center_distance, fixed(-500));
DrawPolygon(canvas, last_type, points.begin(), points.size());
}
if (type != RasterBuffer::TerrainType::UNKNOWN) {
if (j == 0) {
// Start first polygon
points.append() = chart.ToScreen(distance, fixed(-500));
points.append() = chart.ToScreen(distance, fixed(h));
} else if (type != last_type) {
// Start new polygon
points.clear();
const fixed center_distance = (distance + last_distance) / 2;
points.append() = chart.ToScreen(center_distance, fixed(-500));
points.append() = chart.ToScreen(center_distance, fixed(0));
}
if (j + 1 == CrossSectionRenderer::NUM_SLICES) {
// Close and paint last polygon
points.append() = chart.ToScreen(distance, fixed(h));
points.append() = chart.ToScreen(distance, fixed(-500));
DrawPolygon(canvas, type, points.begin(), points.size());
} else if (type == last_type && j != 0) {
// Add single point to polygon
points.append() = chart.ToScreen(distance, fixed(h));
}
}
last_type = type;
last_distance = distance;
}
}
int DirectXDraw9::DrawPolygon( unsigned int pnum, int cx, int cy, unsigned int begin, unsigned int end )
{
return DrawPolygon( pnum, cx, cy, 0, begin, end );
/*unsigned int i, n;
struct CUSTOMVERTEX_LIST *next;
struct CUSTOMVERTEX *cv;
if( pnum > pvmax )
{
// 番号が不正なので最後の番号を使う。
pnum = pvmax;
}
if( pv[ pnum ].type == 1 )
{
// 配列
// 描画先座標との差分をとっておく。
cx -= (int)pv[ pnum ].vertex.cv[ 0 ].x;
cy -= (int)pv[ pnum ].vertex.cv[ 0 ].y;
// 新配列の確保。
cv = (struct CUSTOMVERTEX *)calloc( pv[ pnum ].read.num, sizeof(struct CUSTOMVERTEX) );
// 頂点数を保存。
n = end - begin;//pv[ pnum ].read.num;
// コピーしつつ座標移動。
for( i = 0 ; i < pv[ pnum ].read.num ; ++i )
{
cv[ i ].x = pv[ pnum ].vertex.cv[ i ].x + cx;
cv[ i ].y = pv[ pnum ].vertex.cv[ i ].y + cy;
cv[ i ].z = pv[ pnum ].vertex.cv[ i ].z;
#ifdef USERHW
cv[ i ].rhw = pv[ pnum ].vertex.cv[ i ].rhw;
#endif
cv[ i ].u = pv[ pnum ].vertex.cv[ i ].u;
cv[ i ].v = pv[ pnum ].vertex.cv[ i ].v;
cv[ i ].color = pv[ pnum ].vertex.cv[ i ].color;
}
}else// if( pv[ pnum ].type == 2 )
{
// リスト
// 描画先座標との差分をとっておく。
next = pv[ pnum ].vertex.cvl;
cx -= (int)next->x;
cy -= (int)next->y;
// 新配列の確保。
cv = (struct CUSTOMVERTEX *)calloc( pv[ pnum ].max, sizeof(struct CUSTOMVERTEX) );
// 頂点数を保存。
n = end - begin;//pv[ pnum ].max;
// コピーしつつ座標移動。
next = pv[ pnum ].vertex.cvl;
for( i = 0 ; i < begin ; ++i )
{
next = next->next;
}
for( i = 0 ; i < pv[ pnum ].max ; ++i )
{
cv[ i ].x = next->x + cx;
cv[ i ].y = next->y + cy;
cv[ i ].z = next->z;
#ifdef USERHW
cv[ i ].rhw = next->rhw;
#endif
cv[ i ].u = next->u;
cv[ i ].v = next->v;
cv[ i ].color = next->color;
next = next->next;
}
}
switch( pv[ pnum ].filltype )
{
case D3DPT_TRIANGLELIST :
n = n / 3;
break;
case D3DPT_TRIANGLESTRIP:
n = n - 2;
break;
case D3DPT_TRIANGLEFAN:
n = n - 2;
break;
};
// デバッグ表示！！！！！！！！！
// DrawBox( pv[ pnum ].space[ 0 ], pv[ pnum ].space[ 2 ], pv[ pnum ].space[ 1 ] - pv[ pnum ].space[ 0 ], pv[ pnum ].space[ 3 ] - pv[ pnum ].space[ 2 ], 0x7f00ffff );
D3DDev->SetTexture( 0, pv[ pnum ].txnum >= texmax ? NULL : dxtex[ pv[ pnum ].txnum ].tex );
D3DDev->SetFVF( MIKAN_CUSTOMVERTEX_2D );//D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1
if( FAILED( D3DDev->DrawPrimitiveUP( pv[ pnum ].filltype, n, cv, sizeof( CUSTOMVERTEX ) ) ) ){ return -1; }
DX_FREE( cv );*/
return 0;
}
/* ---------------------------------------------------------------------------
* toggles the selection of any kind of object
* the different types are defined by search.h
*/
bool
SelectObject (void)
{
void *ptr1, *ptr2, *ptr3;
LayerTypePtr layer;
int type;
bool changed = true;
type = SearchScreen (Crosshair.X, Crosshair.Y, SELECT_TYPES,
&ptr1, &ptr2, &ptr3);
if (type == NO_TYPE || TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
return (false);
switch (type)
{
case VIA_TYPE:
AddObjectToFlagUndoList (VIA_TYPE, ptr1, ptr1, ptr1);
TOGGLE_FLAG (SELECTEDFLAG, (PinTypePtr) ptr1);
DrawVia ((PinTypePtr) ptr1, 0);
break;
case LINE_TYPE:
{
LineType *line = (LineTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (LINE_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, line);
DrawLine (layer, line, 0);
break;
}
case RATLINE_TYPE:
{
RatTypePtr rat = (RatTypePtr) ptr2;
AddObjectToFlagUndoList (RATLINE_TYPE, ptr1, ptr1, ptr1);
TOGGLE_FLAG (SELECTEDFLAG, rat);
DrawRat (rat, 0);
break;
}
case ARC_TYPE:
{
ArcType *arc = (ArcTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (ARC_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, arc);
DrawArc (layer, arc, 0);
break;
}
case TEXT_TYPE:
{
TextType *text = (TextTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (TEXT_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, text);
DrawText (layer, text, 0);
break;
}
case POLYGON_TYPE:
{
PolygonType *poly = (PolygonTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (POLYGON_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, poly);
DrawPolygon (layer, poly, 0);
/* changing memory order no longer effects draw order */
break;
}
case PIN_TYPE:
AddObjectToFlagUndoList (PIN_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, (PinTypePtr) ptr2);
DrawPin ((PinTypePtr) ptr2, 0);
break;
case PAD_TYPE:
AddObjectToFlagUndoList (PAD_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, (PadTypePtr) ptr2);
DrawPad ((PadTypePtr) ptr2, 0);
break;
case ELEMENTNAME_TYPE:
{
ElementTypePtr element = (ElementTypePtr) ptr1;
/* select all names of the element */
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
TOGGLE_FLAG (SELECTEDFLAG, text);
}
END_LOOP;
DrawElementName (element, 0);
break;
}
case ELEMENT_TYPE:
{
ElementTypePtr element = (ElementTypePtr) ptr1;
/* select all pins and names of the element */
PIN_LOOP (element);
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
TOGGLE_FLAG (SELECTEDFLAG, pin);
}
END_LOOP;
PAD_LOOP (element);
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
TOGGLE_FLAG (SELECTEDFLAG, pad);
}
END_LOOP;
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
TOGGLE_FLAG (SELECTEDFLAG, text);
}
END_LOOP;
AddObjectToFlagUndoList (ELEMENT_TYPE, element, element, element);
TOGGLE_FLAG (SELECTEDFLAG, element);
if (PCB->ElementOn &&
((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT ||
PCB->InvisibleObjectsOn))
if (PCB->ElementOn)
{
DrawElementName (element, 0);
DrawElementPackage (element, 0);
}
if (PCB->PinOn)
DrawElementPinsAndPads (element, 0);
break;
}
}
Draw ();
IncrementUndoSerialNumber ();
return (changed);
}
static MagickBooleanType ScribbleImage (MagickWand *canvas)
{
DrawingWand
*picasso;
PixelWand
*color;
picasso=NewDrawingWand();
color=NewPixelWand();
(void) PushDrawingWand(picasso);
{
DrawSetViewbox(picasso,0,0,(ssize_t) MagickGetImageWidth(canvas),
(ssize_t) MagickGetImageHeight(canvas));
DrawScale(picasso,1.101,1.08);
DrawTranslate(picasso,-23.69,-22.97);
DrawRotate(picasso,0);
(void) PixelSetColor(color,"#ffffff");
DrawSetFillColor(picasso,color);
DrawRectangle(picasso,23.69,22.97,564.6,802.2);
DrawSetFillAlpha(picasso,1.0);
(void) PixelSetColor(color,"none");
DrawSetFillColor(picasso,color);
DrawSetStrokeColor(picasso,color);
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
DrawPushDefs(picasso);
{
DrawPushClipPath(picasso,"clip_1");
{
(void) PushDrawingWand(picasso);
{
DrawRectangle(picasso,0,0,595.3,841.9);
}
(void) PopDrawingWand(picasso);
}
DrawPopClipPath(picasso);
}
DrawPopDefs(picasso);
(void) PushDrawingWand(picasso);
{
(void) DrawSetClipPath(picasso, "url(#clip_1)");
(void) PushDrawingWand(picasso);
{
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,4.032);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#ff0000");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#ff00ff");
DrawSetFillColor(picasso,color);
DrawRectangle(picasso,72,72,144,144);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,9);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#00ff00");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#0080ff");
DrawSetFillColor(picasso,color);
DrawRoundRectangle(picasso,72,216,360,432,9,9);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[37] =
{
{ 378.1,81.72 }, { 381.1,79.56 }, { 384.3,78.12 }, { 387.6,77.33 },
{ 391.1,77.11 }, { 394.6,77.62 }, { 397.8,78.77 }, { 400.9,80.57 },
{ 403.6,83.02 }, { 523.9,216.8 }, { 526.2,219.7 }, { 527.6,223 },
{ 528.4,226.4 }, { 528.6,229.8 }, { 528,233.3 }, { 526.9,236.5 },
{ 525.1,239.5 }, { 522.6,242.2 }, { 495.9,266.3 }, { 493,268.5 },
{ 489.7,269.9 }, { 486.4,270.8 }, { 482.9,270.9 }, { 479.5,270.4 },
{ 476.2,269.3 }, { 473.2,267.5 }, { 470.4,265 }, { 350,131.2 },
{ 347.8,128.3 }, { 346.4,125.1 }, { 345.6,121.7 }, {345.4,118.2 },
{ 346,114.8 }, { 347.1,111.5 }, { 348.9,108.5 }, { 351.4,105.8 },
{ 378.1,81.72 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,2.016);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#000080");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#c2c280");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,37,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,3.024);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#000080");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#000080");
DrawSetFillColor(picasso,color);
DrawEllipse(picasso,489.6,424.8,72,129.6,0,360);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[48] =
{
{ 213.8,25.13}, { 216.7,24.48 }, {219.8,24.55 }, { 223.1,25.42 },
{ 226.7,27 }, { 230.3,29.3 }, { 234.1,32.26 }, { 237.9,35.86 },
{ 241.8,40.03 }, { 249.7,50.11 }, { 257.4,62.14 }, { 264.8,75.89 },
{ 271.6,91.15 }, { 277.3,106.8 }, { 281.6,121.8 }, { 284.4,135.9 },
{ 285.7,148.5 }, { 285.6,159.6 }, { 284.9,164.3 }, { 283.8,168.5 },
{ 282.5,172.1 }, { 280.7,175 }, { 278.5,177.3 }, { 275.9,178.7 },
{ 273,179.4 }, { 269.9,179.3 }, { 266.6,178.4 }, { 263.1,176.8 },
{ 259.5,174.5}, { 255.7,171.6 }, { 251.9,168 }, { 248,163.8 },
{ 244.1,159 }, { 240.1,153.7 }, { 232.3,141.7 }, { 225,127.9 },
{ 218.2,112.7 }, { 212.5,97.06 }, { 208.2,82.01 }, { 205.4,67.97 },
{ 204,55.3 }, { 204.3,44.35 }, { 204.9,39.6 }, { 205.9,35.42 },
{ 207.4,31.82 }, { 209.2,28.87 }, { 211.3,26.64}, { 213.8,25.13 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,3.024);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#ff8000");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#00ffff");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,48,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,12.02);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
(void) PixelSetColor(color,"none");
DrawSetFillColor(picasso,color);
DrawArc(picasso,360,554.4,187.2,237.6,0,90);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,9);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#4000c2");
DrawSetFillColor(picasso,color);
DrawEllipse(picasso,388.8,626.4,100.8,122.4,0,90);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[6] =
{
{ 180,504 }, { 282.7,578.6 }, { 243.5,699.4 }, { 116.5,699.4 },
{ 77.26,578.6 }, { 180,504 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,9);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#800000");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,6,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[11] =
{
{ 180,504 }, { 211.8,568.3 }, { 282.7,578.6 }, { 231.3,628.7 },
{ 243.5,699.4 }, { 180,666 }, { 116.5,699.4 }, { 128.7,628.7 },
{ 77.26,578.6 }, { 148.2,568.3 }, { 180,504 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,9);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#800000");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,11,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[15] =
{
{ 540,288 }, { 561.6,216 }, { 547.2,43.2 }, { 280.8,36 },
{ 302.4,194.4 }, { 331.2,64.8 }, { 504,64.8 }, { 475.2,115.2 },
{ 525.6,93.6 }, { 496.8,158.4 }, { 532.8,136.8 }, { 518.4,180 },
{ 540,172.8 }, { 540,223.2 }, { 540,288 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,5.976);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#ffff00");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,15,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[7] =
{
{ 57.6,640.8 }, { 57.6,784.8 }, { 194.4,799.2 }, { 259.2,777.6 },
{ 151.2,756 }, { 86.4,748.8 }, { 57.6,640.8 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,5.976);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#ffff00");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,7,points);
}
(void) PopDrawingWand(picasso);
(void) PushDrawingWand(picasso);
{
const PointInfo points[193] =
{
{ 27.86,565.3 }, { 29.66,550.8 }, { 31.97,538.1 }, { 34.85,527.1 },
{ 38.09,517.7 }, { 41.83,509.8 }, { 45.86,503.1 }, { 50.33,497.6 },
{ 55.08,493.2 }, { 60.19,489.8 }, { 65.45,487.3 }, { 70.92,485.4 },
{ 76.61,484.2 }, { 88.42,483 }, { 100.4,482.9 }, { 108.4,482.2 },
{ 119.8,480.3 }, { 150.8,474.1 }, { 189.4,466.6 }, { 210.3,463 },
{ 231.5,459.9 }, { 252.4,457.8 }, { 272.7,456.6 }, { 291.8,456.9 },
{ 300.7,457.7 }, { 309.1,458.9 }, { 316.9,460.6 }, { 324.1,462.8 },
{ 330.7,465.6 }, { 336.4,469 }, { 341.3,473 }, { 345.3,477.7 },
{ 348.4,483.1 }, { 350.4,489.2}, { 352.4,495.4 }, { 355.2,500.9 },
{ 358.8,505.8 }, { 363,510 }, { 367.8,513.6 }, { 373,516.8 },
{ 378.6,519.6 }, { 384.3,521.8 }, { 396.4,525.4 }, { 408.2,527.9 },
{ 428,531.2 }, { 434.6,532.9 }, { 436.7,533.8 }, { 437.8,534.9 },
{ 437.8,536.2 }, { 436.8,537.8 }, { 434.5,539.6 }, { 430.9,541.8 },
{ 419.3,547.6 }, { 401.3,555.2 }, { 342.4,577.9 }, {325.2,584.9 },
{ 311,591.3 }, { 300,597.3 }, { 291.6,602.8 }, { 285.8,607.8 },
{ 282.3,612.3 }, { 281.4,614.4 }, { 280.9,616.2 }, { 281.2,619.6 },
{ 282.1,621.2 }, { 283.3,622.6 }, { 286.8,624.9 }, { 291.5,626.6 },
{ 297.1,627.8 }, { 303.6,628.3 }, { 310.5,628.3 }, { 317.9,627.6 },
{ 325.2,626.3 }, { 332.6,624.3 }, { 339.5,621.7 }, { 345.9,618.4 },
{ 351.4,614.4 }, { 353.9,612.2 }, { 356,609.8 }, { 357.9,607.1 },
{ 359.4,604.3 }, { 360.6,601.3 }, { 361.4,598.2 }, { 361.7,594.9 },
{ 361.7,591.3 }, { 361.2,587.7 }, { 360.1,583.7 }, { 358.6,579.7 },
{ 356.4,575.4 }, { 353.7,570.9 }, { 350.4,566.2 }, { 346.4,561.3 },
{ 341.8,556.2 }, { 336.5,550.9 }, { 330.6,545.5 }, { 323.8,539.8 },
{ 316.2,533.9 }, { 298.7,521.5 }, { 277.8,508.2 }, { 256.1,495.5 },
{ 236,484.5 }, { 217.7,475.1 }, { 200.8,467.1 }, { 185.6,460.7 },
{ 171.9,455.5 }, { 159.6,451.6 }, { 148.6,448.8 }, { 139,447 },
{ 130.5,446.2 }, { 123.3,446.2 }, { 117.1,446.9 }, { 112,448.3 },
{ 107.9,450.2 }, { 104.8,452.5 }, { 102.5,455.2 }, { 101,458.1 },
{ 100.2,461.2 }, { 100.2,464.3 }, { 100.7,467.4 }, { 101.8,470.3 },
{ 103.4,473 }, { 105.4,475.3 }, { 107.8,477.1 }, { 110.5,478.4 },
{ 113.4,479.1 }, { 116.5,478.9 }, { 119.7,478 }, { 123,476.2 },
{ 126.4,473.3 }, { 129.6,469.2 }, { 132.7,463.9 }, { 135.2,458.4 },
{ 136.6,453.7 }, { 137,449.9 }, { 136.6,446.8 }, { 135.4,444.5 },
{ 133.3,442.9 }, { 130.8,441.9 }, { 127.5,441.4 }, { 123.9,441.6 },
{ 119.8,442.3 }, { 110.7,445.1 }, { 101.1,449.5 }, { 91.37,455.2 },
{ 82.37,461.9 }, { 74.66,469.2 }, { 71.57,473 }, { 68.98,476.8 },
{ 67.03,480.7 }, { 65.81,484.4 }, { 65.45,488.2 }, { 65.95,491.7 },
{ 67.46,495.1 }, { 69.98,498.3 }, { 73.66,501.3 }, { 78.55,503.9 },
{ 84.82,506.3 }, { 92.38,508.2 }, { 107.1,511.6 }, { 118.2,514.8 },
{ 125.9,517.8 }, { 130.7,520.4 }, { 132.1,521.7 }, { 132.8,522.9 },
{ 133,524.2 }, { 132.6,525.3 }, { 131.8,526.5 }, { 130.5,527.5 },
{ 126.6,529.6 }, { 121.5,531.7 }, { 115.3,533.7 }, { 101.4,537.6 },
{ 87.55,541.8 }, { 81.36,544 }, { 76.25,546.3 }, { 71.64,549.5 },
{ 66.89,554.1 }, { 62.14,559.8 }, { 57.38,566.1 }, { 48.17,579.6 },
{ 39.96,591.4 }, { 36.43,595.9 }, { 34.78,597.6 }, { 33.26,598.8 },
{ 31.9,599.6 }, { 30.67,599.9 }, { 29.59,599.7 }, { 28.66,598.8 },
{ 27.86,597.4 }, { 27.29,595.2 }, { 26.64,588.7 }, { 26.86,578.8 },
{ 27.86,565.3 }
};
DrawSetStrokeAntialias(picasso,MagickTrue);
DrawSetStrokeWidth(picasso,5.904);
DrawSetStrokeLineCap(picasso,RoundCap);
DrawSetStrokeLineJoin(picasso,RoundJoin);
(void) DrawSetStrokeDashArray(picasso,0,(const double *)NULL);
(void) PixelSetColor(color,"#4000c2");
DrawSetStrokeColor(picasso,color);
DrawSetFillRule(picasso,EvenOddRule);
(void) PixelSetColor(color,"#ffff00");
DrawSetFillColor(picasso,color);
DrawPolygon(picasso,193,points);
}
(void) PopDrawingWand(picasso);
}
(void) PopDrawingWand(picasso);
}
(void) PopDrawingWand(picasso);
(void) MagickDrawImage(canvas,picasso);
color=DestroyPixelWand(color);
picasso=DestroyDrawingWand(picasso);
return(MagickTrue);
}
/* ----------------------------------------------------------------------
* selects/unselects all visible objects within the passed box
* Flag determines if the block is to be selected or unselected
* returns true if the state of any object has changed
*/
bool
SelectBlock (BoxTypePtr Box, bool Flag)
{
bool changed = false;
if (PCB->RatOn || !Flag)
RAT_LOOP (PCB->Data);
{
if (LINE_IN_BOX ((LineTypePtr) line, Box) &&
!TEST_FLAG (LOCKFLAG, line) && TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (RATLINE_TYPE, line, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (PCB->RatOn)
DrawRat (line, 0);
changed = true;
}
}
END_LOOP;
/* check layers */
LAYER_LOOP(PCB->Data, max_copper_layer + 2);
{
if (layer == & PCB->Data->SILKLAYER)
{
if (! (PCB->ElementOn || !Flag))
continue;
}
else if (layer == & PCB->Data->BACKSILKLAYER)
{
if (! (PCB->InvisibleObjectsOn || !Flag))
continue;
}
else
if (! (layer->On || !Flag))
continue;
LINE_LOOP (layer);
{
if (LINE_IN_BOX (line, Box)
&& !TEST_FLAG (LOCKFLAG, line)
&& TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (LINE_TYPE, layer, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (layer->On)
DrawLine (layer, line, 0);
changed = true;
}
}
END_LOOP;
ARC_LOOP (layer);
{
if (ARC_IN_BOX (arc, Box)
&& !TEST_FLAG (LOCKFLAG, arc)
&& TEST_FLAG (SELECTEDFLAG, arc) != Flag)
{
AddObjectToFlagUndoList (ARC_TYPE, layer, arc, arc);
ASSIGN_FLAG (SELECTEDFLAG, Flag, arc);
if (layer->On)
DrawArc (layer, arc, 0);
changed = true;
}
}
END_LOOP;
TEXT_LOOP (layer);
{
if (!Flag || TEXT_IS_VISIBLE(PCB, layer, text))
{
if (TEXT_IN_BOX (text, Box)
&& !TEST_FLAG (LOCKFLAG, text)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
if (TEXT_IS_VISIBLE(PCB, layer, text))
DrawText (layer, text, 0);
changed = true;
}
}
}
END_LOOP;
POLYGON_LOOP (layer);
{
if (POLYGON_IN_BOX (polygon, Box)
&& !TEST_FLAG (LOCKFLAG, polygon)
&& TEST_FLAG (SELECTEDFLAG, polygon) != Flag)
{
AddObjectToFlagUndoList (POLYGON_TYPE, layer, polygon, polygon);
ASSIGN_FLAG (SELECTEDFLAG, Flag, polygon);
if (layer->On)
DrawPolygon (layer, polygon, 0);
changed = true;
}
}
END_LOOP;
}
END_LOOP;
/* elements */
ELEMENT_LOOP (PCB->Data);
{
{
bool gotElement = false;
if ((PCB->ElementOn || !Flag)
&& !TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn))
{
if (BOX_IN_BOX
(&ELEMENT_TEXT (PCB, element).BoundingBox, Box)
&& !TEST_FLAG (LOCKFLAG, &ELEMENT_TEXT (PCB, element))
&& TEST_FLAG (SELECTEDFLAG,
&ELEMENT_TEXT (PCB, element)) != Flag)
{
/* select all names of element */
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE,
element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
if (PCB->ElementOn)
DrawElementName (element, 0);
changed = true;
}
if ((PCB->PinOn || !Flag) && ELEMENT_IN_BOX (element, Box))
if (TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
AddObjectToFlagUndoList (ELEMENT_TYPE,
element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pin) != Flag)
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
if (PCB->PinOn)
DrawElement (element, 0);
changed = true;
gotElement = true;
}
}
if ((PCB->PinOn || !Flag) && !TEST_FLAG (LOCKFLAG, element) && !gotElement)
{
PIN_LOOP (element);
{
if ((VIA_OR_PIN_IN_BOX (pin, Box)
&& TEST_FLAG (SELECTEDFLAG, pin) != Flag))
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (PAD_IN_BOX (pad, Box)
&& TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
}
}
}
END_LOOP;
/* end with vias */
if (PCB->ViaOn || !Flag)
VIA_LOOP (PCB->Data);
{
if (VIA_OR_PIN_IN_BOX (via, Box)
&& !TEST_FLAG (LOCKFLAG, via)
&& TEST_FLAG (SELECTEDFLAG, via) != Flag)
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
if (PCB->ViaOn)
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
if (changed)
{
Draw ();
IncrementUndoSerialNumber ();
}
return (changed);
}
void PhysicsDebugGraphicsAdapter::DrawSolidPolygon(b2Vec2 const *vertices,
int32 vertexCount, b2Color const &color)
{
DrawPolygon(vertices, vertexCount, color);
}
/* ----------------------------------------------------------------------
* selects/unselects all objects which were found during a connection scan
* Flag determines if they are to be selected or unselected
* returns true if the state of any object has changed
*
* text objects and elements cannot be selected by this routine
*/
bool
SelectConnection (bool Flag)
{
bool changed = false;
if (PCB->RatOn)
RAT_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, line))
{
AddObjectToFlagUndoList (RATLINE_TYPE, line, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
DrawRat (line, 0);
changed = true;
}
}
END_LOOP;
VISIBLELINE_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, line) && !TEST_FLAG (LOCKFLAG, line))
{
AddObjectToFlagUndoList (LINE_TYPE, layer, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
DrawLine (layer, line, 0);
changed = true;
}
}
ENDALL_LOOP;
VISIBLEARC_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, arc) && !TEST_FLAG (LOCKFLAG, arc))
{
AddObjectToFlagUndoList (ARC_TYPE, layer, arc, arc);
ASSIGN_FLAG (SELECTEDFLAG, Flag, arc);
DrawArc (layer, arc, 0);
changed = true;
}
}
ENDALL_LOOP;
VISIBLEPOLYGON_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, polygon) && !TEST_FLAG (LOCKFLAG, polygon))
{
AddObjectToFlagUndoList (POLYGON_TYPE, layer, polygon, polygon);
ASSIGN_FLAG (SELECTEDFLAG, Flag, polygon);
DrawPolygon (layer, polygon, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->PinOn && PCB->ElementOn)
{
ALLPIN_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element) && TEST_FLAG (FOUNDFLAG, pin))
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
DrawPin (pin, 0);
changed = true;
}
}
ENDALL_LOOP;
ALLPAD_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element) && TEST_FLAG (FOUNDFLAG, pad))
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
DrawPad (pad, 0);
changed = true;
}
}
ENDALL_LOOP;
}
if (PCB->ViaOn)
VIA_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, via) && !TEST_FLAG (LOCKFLAG, via))
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
Draw ();
return (changed);
}
void TimelineDC::DrawSolidFlag(const std::wstring& /* tooltip */, int x, int y)
{
DrawPolygon({ { x, y - 20 },{ x + 7, y - 16 },{ x, y - 12 } });
MoveTo(x, y);
LineTo(x, y - 20);
}
virtual void _Draw()
{
DrawPolygon(float_polygon);
}
/*
================
idCollisionModelManagerLocal::DrawNodePolygons
================
*/
void idCollisionModelManagerLocal::DrawNodePolygons( cm_model_t* model, cm_node_t* node,
const idVec3& origin, const idMat3& axis,
const idVec3& viewOrigin, const float radius )
{
int i;
cm_polygon_t* p;
cm_polygonRef_t* pref;
while( 1 )
{
for( pref = node->polygons; pref; pref = pref->next )
{
p = pref->p;
if( radius )
{
// polygon bounds should overlap with trace bounds
for( i = 0; i < 3; i++ )
{
if( p->bounds[0][i] > viewOrigin[i] + radius )
{
break;
}
if( p->bounds[1][i] < viewOrigin[i] - radius )
{
break;
}
}
if( i < 3 )
{
continue;
}
}
if( p->checkcount == checkCount )
{
continue;
}
if( !( p->contents & cm_contentsFlagByIndex[cm_drawMask.GetInteger()] ) )
{
continue;
}
DrawPolygon( model, p, origin, axis, viewOrigin );
p->checkcount = checkCount;
}
if( node->planeType == -1 )
{
break;
}
if( radius && viewOrigin[node->planeType] > node->planeDist + radius )
{
node = node->children[0];
}
else if( radius && viewOrigin[node->planeType] < node->planeDist - radius )
{
node = node->children[1];
}
else
{
DrawNodePolygons( model, node->children[1], origin, axis, viewOrigin, radius );
node = node->children[0];
}
}
}
// Rotina que chama os métodos de desenho da classe DebugDraw para desenhar os objetos da cena
void DebugDraw::DrawFixture(b2Fixture* fixture, b2Color color)
{
const b2Transform& xf = fixture->GetBody()->GetTransform();
switch (fixture->GetType())
{
case b2Shape::e_circle:
{
b2CircleShape* circle = (b2CircleShape*)fixture->GetShape();
b2Vec2 center = b2Mul(xf, circle->m_p);
float32 radius = circle->m_radius;
DrawCircle(center, radius, color);
}
break;
case b2Shape::e_polygon:
{
b2PolygonShape* poly = (b2PolygonShape*)fixture->GetShape();
int32 vertexCount = poly->m_count;
b2Assert(vertexCount <= b2_maxPolygonVertices);
b2Vec2 vertices[b2_maxPolygonVertices];
for (int32 i = 0; i < vertexCount; ++i)
{
vertices[i] = b2Mul(xf, poly->m_vertices[i]);
}
DrawPolygon(vertices, vertexCount, color);
}
break;
case b2Shape::e_edge:
{
b2EdgeShape* edge = (b2EdgeShape*)fixture->GetShape();
int32 vertexCount;
b2Vec2 vertices[b2_maxPolygonVertices];
int i=0;
if (edge->m_hasVertex0)
{
vertices[i] = b2Mul(xf, edge->m_vertex0);
i++;
}
vertices[i] = b2Mul(xf, edge->m_vertex1); i++;
vertices[i] = b2Mul(xf, edge->m_vertex2); i++;
if (edge->m_hasVertex3)
{
vertices[i] = b2Mul(xf, edge->m_vertex3);
i++;
}
vertexCount = i;
DrawPolygon(vertices, vertexCount, color);
}
break;
}
}
void VisitPolygon(const AirspacePolygon &airspace) {
DrawPolygon(airspace.GetPoints());
}
int main (int argc, char **argv) {
srand(time(NULL));
int i, j, k;
float minSize = 10000, maxSize = 1.0, minPeriod = 0.1, minStable = 0.1;
PStack im2Regions = NewPStack(100);
Image im2 = ReadPGMFile(argv[1]);
Image out = ConvertImage1(CopyImage(im2));
fprintf(stderr,"Read in image %s with dimensions %d %d\n",argv[1],im2->rows,im2->cols);
FindMSERegions(im2,im2Regions,minSize,maxSize,1,2,FALSE,TRUE);
PStack dc = NewPStack(10);
for(i=0;i<im2Regions->stacksize;i++) {
Region re = im2Regions->items[i];
float area = PolygonArea(re->border);
float numberOfSections = area / 44000;
if ( numberOfSections >= 1 && numberOfSections < 5 ) {
PolygonACD(re->border,0.06,dc);
}
}
Region cc = im2Regions->items[i];
//DrawPolygon(cc->border,out,PIX3(0,255,0));
for(i=0;i<dc->stacksize;i++) {
Polygon border = dc->items[i];
int area = PolygonArea(border);
if ( area < 44000 || area > 44000 * 1.6 ) continue;
PolygonVertexEvolution(border,4);
int color = RandomColor(150);
for(j=0;j<border->numberOfVertices;j++) {
Ellipse e = NewEllipse(border->vertices[j].x,border->vertices[j].y,5,5,0);
DrawEllipse(e,out,color); free(e);
}
DrawPolygon(border,out,color);
}
WritePPM("sections.ppm",out);
//RegionsToSIFTDescriptors(im1Regions,im1Descriptors,4,8,41);
//fprintf(stderr,"Created %d descriptors from %d regions in %2.2f seconds\n",im1Descriptors->stacksize,im1Regions->stacksize,CPUTIME-t0);
//PrintSIFTDescriptors("csift1",im1Descriptors);
/*
PStack im2Regions = NewPStack(100);
PStack im2Descriptors = NewPStack(100);
t0 = CPUTIME;
Image im2 = ReadPGMFile(argv[2]);
FindMSERegions(im2,im2Regions,minSize,maxSize,minPeriod,minStable);
RegionsToSIFTDescriptors(im2Regions,im2Descriptors,4,8,41);
fprintf(stderr,"Created %d descriptors from %d regions in %2.2f seconds\n",im2Descriptors->stacksize,im2Regions->stacksize,CPUTIME-t0);
PStack matches = NewPStack(100);
double **transform = AllocDMatrix(3,3,0,0);
FindMatches(im1Descriptors,im2Descriptors,matches,10);
fprintf(stderr,"Found %d initial matches.\n",matches->stacksize);
ScreenMatches(matches,transform);
fprintf(stderr,"A1 = [ ");
for(k=0;k<3;k++)fprintf(stderr,"%f %f %f;",transform[k][0],transform[k][1],transform[k][2]);
fprintf(stderr,"]\n");
Image im3 = CreateImage(im1->rows,im1->cols);
AffineTransformImage(im2,im3,NULL,transform);
for (i=0;i<im1->rows;i++) {
for (j=0;j<im1->cols;j++) {
int rv = MAX(0,im1->pixels[i][j]);
int bv = MAX(0,im3->pixels[i][j]);
im3->pixels[i][j] = PIX3(rv,0,bv);
}}
WritePPM("affine.ppm",im3);
*/
return 0;
}
