void SVG_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
FILL_T aFill, int aWidth )
{
if( aCornerList.size() <= 1 )
return;
setFillMode( aFill );
SetCurrentLineWidth( aWidth );
switch( aFill )
{
case NO_FILL:
fprintf( outputFile, "<polyline fill=\"none;\"\n" );
break;
case FILLED_WITH_BG_BODYCOLOR:
case FILLED_SHAPE:
fprintf( outputFile, "<polyline style=\"fill-rule:evenodd;\"\n" );
break;
}
DPOINT pos = userToDeviceCoordinates( aCornerList[0] );
fprintf( outputFile, "points=\"%d,%d\n", (int) pos.x, (int) pos.y );
for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
{
pos = userToDeviceCoordinates( aCornerList[ii] );
fprintf( outputFile, "%d,%d\n", (int) pos.x, (int) pos.y );
}
// Close/(fill) the path
fprintf( outputFile, "\" /> \n" );
}
void ofCairoRenderer::setStyle(const ofStyle & style){
//color
setColor((int)style.color.r, (int)style.color.g, (int)style.color.b, (int)style.color.a);
//bg color
//setBackgroundColor(style.bgColor);
//circle resolution - don't worry it only recalculates the display list if the res has changed
setCircleResolution(style.circleResolution);
setSphereResolution(style.sphereResolution);
//setCurveResolution(style.curveResolution);
//line width - finally!
setLineWidth(style.lineWidth);
//rect mode: corner/center
setRectMode(style.rectMode);
//poly mode: winding type
//setPolyMode(style.polyMode);
//fill
setFillMode(style.bFill?OF_FILLED:OF_OUTLINE);
//smoothing
//setSmoothingEnabled(style.smoothing);
//blending
setBlendMode(style.blendingMode);
//bitmap draw mode
//setDrawBitmapMode(style.drawBitmapMode);
}
void ConnectionTracerRenderer::draw() {
if (!_params.enabled.get()) {
return;
}
auto renderer = ofGetCurrentRenderer();
renderer->pushStyle();
renderer->setFillMode(OF_OUTLINE);
for (const auto& entity : _context.observers) {
for (const auto& connection : entity->getObserverConnections()) {
drawTracer(*connection, renderer);
}
for (const auto& connection : entity->getOccurrenceConnections()) {
drawTracer(*connection, renderer);
}
}
for (const auto& entity : _context.occurrences) {
for (const auto& connection : entity->getObserverConnections()) {
drawTracer(*connection, renderer);
}
for (const auto& connection : entity->getOccurrenceConnections()) {
drawTracer(*connection, renderer);
}
}
renderer->popStyle();
}
void ModelRender::RenderPipelineLib::addRenderPipeline(ModelRender::RenderKey key,
gpu::ShaderPointer& vertexShader,
gpu::ShaderPointer& pixelShader) {
gpu::Shader::BindingSet slotBindings;
slotBindings.insert(gpu::Shader::Binding(std::string("skinClusterBuffer"), ModelRender::SKINNING_GPU_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("materialBuffer"), ModelRender::MATERIAL_GPU_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("diffuseMap"), ModelRender::DIFFUSE_MAP_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("normalMap"), ModelRender::NORMAL_MAP_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("specularMap"), ModelRender::SPECULAR_MAP_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("emissiveMap"), ModelRender::LIGHTMAP_MAP_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), ModelRender::LIGHT_BUFFER_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("normalFittingMap"), DeferredLightingEffect::NORMAL_FITTING_MAP_SLOT));
gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vertexShader, pixelShader));
gpu::Shader::makeProgram(*program, slotBindings);
auto locations = std::make_shared<Locations>();
initLocations(program, *locations);
auto state = std::make_shared<gpu::State>();
// Backface on shadow
if (key.isShadow()) {
state->setCullMode(gpu::State::CULL_FRONT);
state->setDepthBias(1.0f);
state->setDepthBiasSlopeScale(4.0f);
} else {
state->setCullMode(gpu::State::CULL_BACK);
}
// Z test depends if transparent or not
state->setDepthTest(true, !key.isTranslucent(), gpu::LESS_EQUAL);
// Blend on transparent
state->setBlendFunction(key.isTranslucent(),
gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA, // For transparent only, this keep the highlight intensity
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
// Good to go add the brand new pipeline
auto pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
insert(value_type(key.getRaw(), RenderPipeline(pipeline, locations)));
if (!key.isWireFrame()) {
RenderKey wireframeKey(key.getRaw() | RenderKey::IS_WIREFRAME);
auto wireframeState = std::make_shared<gpu::State>(state->getValues());
wireframeState->setFillMode(gpu::State::FILL_LINE);
// create a new RenderPipeline with the same shader side and the wireframe state
auto wireframePipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, wireframeState));
insert(value_type(wireframeKey.getRaw(), RenderPipeline(wireframePipeline, locations)));
}
}
void SVG_PLOTTER::Circle( const wxPoint& pos, int diametre, FILL_T fill, int width )
{
DPOINT pos_dev = userToDeviceCoordinates( pos );
double radius = userToDeviceSize( diametre / 2.0 );
setFillMode( fill );
SetCurrentLineWidth( width );
fprintf( outputFile,
"<circle cx=\"%g\" cy=\"%g\" r=\"%g\" /> \n",
pos_dev.x, pos_dev.y, radius );
}
//=====================================================
GlPolygon::GlPolygon(const vector<Coord> &points,
const vector<Color> &fcolors,
const vector<Color> &ocolors,
const bool filled,
const bool outlined,
const string &textureName,
const float outlineSize) {
setPoints(points);
setFillColors(fcolors);
setOutlineColors(ocolors);
setFillMode(filled);
setOutlineMode(outlined);
setTextureName(textureName);
setOutlineSize(outlineSize);
}
Timing TimingInput::convert(const Dictionary& timingInputDictionary)
{
Timing result;
// FIXME: This method needs to be refactored to handle invalid
// null, NaN, Infinity values better.
// See: http://www.w3.org/TR/WebIDL/#es-double
double startDelay = Timing::defaults().startDelay;
timingInputDictionary.get("delay", startDelay);
setStartDelay(result, startDelay);
double endDelay = Timing::defaults().endDelay;
timingInputDictionary.get("endDelay", endDelay);
setEndDelay(result, endDelay);
String fillMode;
timingInputDictionary.get("fill", fillMode);
setFillMode(result, fillMode);
double iterationStart = Timing::defaults().iterationStart;
timingInputDictionary.get("iterationStart", iterationStart);
setIterationStart(result, iterationStart);
double iterationCount = Timing::defaults().iterationCount;
timingInputDictionary.get("iterations", iterationCount);
setIterationCount(result, iterationCount);
double iterationDuration = 0;
if (timingInputDictionary.get("duration", iterationDuration)) {
setIterationDuration(result, iterationDuration);
}
double playbackRate = Timing::defaults().playbackRate;
timingInputDictionary.get("playbackRate", playbackRate);
setPlaybackRate(result, playbackRate);
String direction;
timingInputDictionary.get("direction", direction);
setPlaybackDirection(result, direction);
String timingFunctionString;
timingInputDictionary.get("easing", timingFunctionString);
setTimingFunction(result, timingFunctionString);
result.assertValid();
return result;
}
void BoundsController::draw() {
if (!_debugParams.showBounds.get()) {
return;
}
auto renderer = ofGetCurrentRenderer();
renderer->pushStyle();
renderer->setFillMode(OF_OUTLINE);
renderer->setColor(_boundsColor);
renderer->drawBox(_params.size.get());
renderer->popStyle();
renderer->drawGrid(_params.size.get() / 2 / 4, // step size
4, // number of steps
true, // labels
true, true, true // x / y /z
);
}
void SVG_PLOTTER::Text( const wxPoint& aPos,
enum EDA_COLOR_T aColor,
const wxString& aText,
double aOrient,
const wxSize& aSize,
enum EDA_TEXT_HJUSTIFY_T aH_justify,
enum EDA_TEXT_VJUSTIFY_T aV_justify,
int aWidth,
bool aItalic,
bool aBold,
bool aMultilineAllowed )
{
setFillMode( NO_FILL );
SetColor( aColor );
SetCurrentLineWidth( aWidth );
// TODO: see if the postscript native text code can be used in SVG plotter
PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify,
aWidth, aItalic, aBold, aMultilineAllowed );
}
//=====================================================
GlPolygon::GlPolygon(const unsigned int nbPoints,
const unsigned int nbFillColors,
const unsigned int nbOutlineColors,
const bool filled,
const bool outlined,
const string &textureName,
const float outlineSize) {
vector<Coord> points;
points.resize(nbPoints);
setPoints(points);
vector<Color> fillColors;
fillColors.resize(nbFillColors,Color(0,0,0,255));
setFillColors(fillColors);
vector<Color> outlineColors;
outlineColors.resize(nbOutlineColors);
setOutlineColors(outlineColors);
setFillMode(filled);
setOutlineMode(outlined);
setTextureName(textureName);
setOutlineSize(outlineSize);
}
void SVG_PLOTTER::PenTo( const wxPoint& pos, char plume )
{
if( plume == 'Z' )
{
if( penState != 'Z' )
{
fputs( "\" />\n", outputFile );
penState = 'Z';
penLastpos.x = -1;
penLastpos.y = -1;
}
return;
}
if( penState == 'Z' ) // here plume = 'D' or 'U'
{
DPOINT pos_dev = userToDeviceCoordinates( pos );
// Ensure we do not use a fill mode when moving tne pen,
// in SVG mode (i;e. we are plotting only basic lines, not a filled area
if( m_fillMode != NO_FILL )
{
setFillMode( NO_FILL );
setSVGPlotStyle();
}
fprintf( outputFile, "<path d=\"M%d %d\n",
(int) pos_dev.x, (int) pos_dev.y );
}
else if( penState != plume || pos != penLastpos )
{
DPOINT pos_dev = userToDeviceCoordinates( pos );
fprintf( outputFile, "L%d %d\n",
(int) pos_dev.x, (int) pos_dev.y );
}
penState = plume;
penLastpos = pos;
}
void SVG_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
{
EDA_RECT rect( p1, wxSize( p2.x -p1.x, p2.y -p1.y ) );
rect.Normalize();
DPOINT org_dev = userToDeviceCoordinates( rect.GetOrigin() );
DPOINT end_dev = userToDeviceCoordinates( rect.GetEnd() );
DSIZE size_dev = end_dev - org_dev;
// Ensure size of rect in device coordinates is > 0
// Inkscape has problems with negative values for width and/or height
DBOX rect_dev( org_dev, size_dev);
rect_dev.Normalize();
setFillMode( fill );
SetCurrentLineWidth( width );
fprintf( outputFile,
"<rect x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" rx=\"%g\" />\n",
rect_dev.GetPosition().x, rect_dev.GetPosition().y,
rect_dev.GetSize().x, rect_dev.GetSize().y,
0.0 // radius of rounded corners
);
}
GlRegularPolygon::GlRegularPolygon(const Coord &position,
const Size &size,
unsigned int numberOfSides,
const Color &fillColor,
const Color &outlineColor,
bool filled,
bool outlined,
const string &textureName,
float outlineSize):
position(position),
size(size),
numberOfSides(numberOfSides),
startAngle(float(M_PI)/2.0f) {
computePolygon();
invertYTexture=false;
setFillColor(fillColor);
setOutlineColor(outlineColor);
setFillMode(filled);
setOutlineMode(outlined);
setTextureName(textureName);
setOutlineSize(outlineSize);
}
void SVG_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
FILL_T fill, int width )
{
/* Draws an arc of a circle, centred on (xc,yc), with starting point
* (x1, y1) and ending at (x2, y2). The current pen is used for the outline
* and the current brush for filling the shape.
*
* The arc is drawn in an anticlockwise direction from the start point to
* the end point
*/
if( radius <= 0 )
return;
if( StAngle > EndAngle )
EXCHG( StAngle, EndAngle );
setFillMode( fill );
SetCurrentLineWidth( width );
// Calculate start point.
DPOINT centre_dev = userToDeviceCoordinates( centre );
double radius_dev = userToDeviceSize( radius );
if( !m_yaxisReversed ) // Should be never the case
{
double tmp = StAngle;
StAngle = -EndAngle;
EndAngle = -tmp;
}
if( m_plotMirror )
{
if( m_mirrorIsHorizontal )
{
StAngle = 1800.0 -StAngle;
EndAngle = 1800.0 -EndAngle;
EXCHG( StAngle, EndAngle );
}
else
{
StAngle = -StAngle;
EndAngle = -EndAngle;
}
}
DPOINT start;
start.x = radius_dev;
RotatePoint( &start.x, &start.y, StAngle );
DPOINT end;
end.x = radius_dev;
RotatePoint( &end.x, &end.y, EndAngle );
start += centre_dev;
end += centre_dev;
double theta1 = DECIDEG2RAD( StAngle );
if( theta1 < 0 )
theta1 = theta1 + M_PI * 2;
double theta2 = DECIDEG2RAD( EndAngle );
if( theta2 < 0 )
theta2 = theta2 + M_PI * 2;
if( theta2 < theta1 )
theta2 = theta2 + M_PI * 2;
int flg_arc = 0; // flag for large or small arc. 0 means less than 180 degrees
if( fabs( theta2 - theta1 ) > M_PI )
flg_arc = 1;
int flg_sweep = 0; // flag for sweep always 0
// Draw a single arc: an arc is one of 3 curve commands (2 other are 2 bezier curves)
// params are start point, radius1, radius2, X axe rotation,
// flag arc size (0 = small arc > 180 deg, 1 = large arc > 180 deg),
// sweep arc ( 0 = CCW, 1 = CW),
// end point
fprintf( outputFile, "<path d=\"M%g %g A%g %g 0.0 %d %d %g %g \" />\n",
start.x, start.y, radius_dev, radius_dev,
flg_arc, flg_sweep,
end.x, end.y );
}
GlPolygon::GlPolygon(const bool filled,const bool outlined,const string &textureName,const float outlineSize) {
setFillMode(filled);
setOutlineMode(outlined);
setTextureName(textureName);
setOutlineSize(outlineSize);
}
