void DrawGLUtils::DrawPoint(const xlColor &color, double x, double y)
{
glColor3ub(color.Red(), color.Green(),color.Blue());
glBegin(GL_POINTS);
glVertex2f(x, y);
glEnd();
}
void DrawGLUtils::DrawLine(const xlColor &color, wxByte alpha,int x1, int y1, int x2, int y2, float width)
{
glLineWidth(width);
glColor4ub(color.Red(), color.Green(),color.Blue(),alpha);
glBegin(GL_LINES);
glVertex2i(x1, y1);
glVertex2i(x2, y2);
glEnd();
}
void add(double x, double y, const xlColor &c) {
resize(curCount + 1);
vertices[curCount * 2] = x;
vertices[curCount * 2 + 1] = y;
colors[curCount*4] = c.Red();
colors[curCount*4 + 1] = c.Green();
colors[curCount*4 + 2] = c.Blue();
colors[curCount*4 + 3] = c.Alpha();
curCount++;
}
void DrawGLUtils::DrawFillRectangle(const xlColor &color, wxByte alpha, int x, int y,int width, int height)
{
glColor4ub(color.Red(), color.Green(),color.Blue(),alpha);
//glColor3ub(color.Red(), color.Green(),color.Blue());
glBegin(GL_QUADS);
glVertex2f(x, y);
glVertex2f(x+width, y);
glVertex2f(x+width, y+height);
glVertex2f(x, y+height);
glEnd();
}
void DrawGLUtils::DrawCircleUnfilled(const xlColor &color, double cx, double cy, double r, float width )
{
static const double inc = PI / 12;
static const double max = 2 * PI;
glLineWidth(width);
glColor3ub(color.Red(), color.Green(),color.Blue());
glBegin(GL_LINE_LOOP);
for(double d = 0; d < max; d += inc) {
glVertex2f(cos(d) * r + cx, sin(d) * r + cy);
}
glEnd();
}
void DrawGLUtils::DrawHBlendedRectangle(const xlColor &left, const xlColor &right, int x1, int y1,int x2, int y2) {
glColor3ub(left.Red(), left.Green(), left.Blue());
glBegin(GL_QUADS);
glVertex2f(x1, y1);
glVertex2f(x1, y2);
glColor3ub(right.Red(), right.Green(),right.Blue());
glVertex2f(x2, y2);
glVertex2f(x2, y1);
glEnd();
}
static void set_pixel_if_not_color(RenderBuffer &buffer, int x, int y, xlColor toColor, xlColor notColor, bool wrapx, bool wrapy)
{
int adjx = x;
int adjy = y;
if (x < 0) {
if (wrapx) {
adjx += buffer.BufferWi;
}
else {
return;
}
}
else if (x >= buffer.BufferWi) {
if (wrapx) {
adjx -= buffer.BufferWi;
}
else {
return;
}
}
if (y < 0) {
if (wrapy) {
adjy += buffer.BufferHt;
}
else {
return;
}
}
else if (y >= buffer.BufferHt) {
if (wrapy) {
adjy -= buffer.BufferHt;
}
else {
return;
}
}
// strip off alpha when comparing
if (buffer.GetTempPixel(adjx, adjy).GetRGB() != notColor.GetRGB()) {
buffer.SetPixel(adjx, adjy, toColor);
}
}
bool PianoRenderCache::Piano_RenderKey(RenderBuffer &buffer, Sprite* sprite, std::hash_map<wxPoint_, int>& drawn,
int style, wxSize& canvas, wxSize& keywh, const wxString &placement, bool clip)
//bool RgbEffects::Sprite::render(wxSize& keywh, wxSize& BufferWH_int, int yscroll, bool Clipping)
{
debug_function(9);
//hash_map<pair<wxPoint, wxSize>, int>& drawn)
//PIANO_STYLE_KEYS sprites have 2 states: on (down) and off (up); draw all sprites; top view or edge view
int drawstate = sprite->ani_state++; //bump to next active (animation) state
if (!drawstate) sprite->ani_state = 0; //stay in inactive state
else
// if ((xy.size() == 1) && (drawstate == -1)) return false; //inactive on/off sprite; don't need tp draw anything
if (drawstate >= sprite->xy.size()) //end of animation
// if (it->repeat > 0) drawstate = 0; //loop immediately
// else if (it->repeat < 0) drawstate = -rnd(); //loop with delay
/*else*/ drawstate = sprite->xy.size() - 1; //stay at last state; don't loop
// wxPoint realxy = sprite->destxy;
// realxy.y += yscroll; //scrolling
debug_more(30, ", dest (%d => %d, %d), #drawn %d", sprite->destxy.x, (clip? sprite->destxy.x: sprite->destxy.x % canvas.x), sprite->destxy.y, drawn.size());
if (clip)
if ((sprite->destxy.x >= buffer.BufferWi) || (sprite->destxy.y >= buffer.BufferHt) || (sprite->destxy.x + keywh.x < 0) || (sprite->destxy.y + keywh.y < 0)) return false; //outside of visible rect
// debug_more(30, ", here1");
wxPoint_ where = sprite->destxy.y * 65536 + (clip? sprite->destxy.x: sprite->destxy.x % canvas.x); //wrap on even key boundary
// debug_more(30, ", here2");
if ((style != PIANO_STYLE_ANIMAGE) && (drawn.find(where) != drawn.end()) && (drawstate <= drawn[where])) { debug_more(30, ", already drawn[0x%x]=%d vs %d", where, drawn[where], drawstate); return false; } //do not redraw older states in same location
drawn[where] = drawstate; //remember highest state drawn in this location
//don't draw overlapping regions more than once
// SetPixel(x-xoffset,(state % ((imght+BufferHt)*speedfactor)) / speedfactor-y,c); //moving up
// SetPixel(x-xoffset,BufferHt+imght-y-(state % ((imght+BufferHt)*speedfactor)) / speedfactor,c); //moving down
//copy sprite image to pixel buffer, scale up/down:
//iterate thru target pixels and pull from sprite in case sizes don't match (need to set all target pixels, but okay to skip some source pixels)
float xscale = (float)sprite->wh.x / keywh.x, yscale = (float)sprite->wh.y / keywh.y; //src -> dest scale factor
// debug_more(30, ", here3");
//TODO: use wxImage.GetData for better performance?
int xofs = !clip? (buffer.BufferWi % (7 * keywh.x)) / 2: 0; //center keys if not clipped
if (WantHistory(style)) debug(20, "draw sprite '%s': set x/y %d/%d + %d/%d to 0x%x", (const char*)sprite->name.ToStdString().c_str(), sprite->destxy.x, sprite->destxy.y, keywh.x, keywh.y, drawstate? sprite->on.GetRGB(): sprite->off.GetRGB()); //.Flush(true);
else debug(20, "draw sprite '%s': copy from x/y[%d/%d] %d/%d + %d/%d => x/y %d/%d + %d/%d, x/y scale = %f/%f", (const char*)sprite->name.ToStdString().c_str(), drawstate, sprite->xy.size(), sprite->xy[drawstate].x, sprite->xy[drawstate].y, sprite->wh.x, sprite->wh.y, sprite->destxy.x, sprite->destxy.y, keywh.x, keywh.y, 1.0 / xscale, 1.0 / yscale); //.Flush(true);
for (int x = 0; x < keywh.x; ++x) //copying to it->w columns in dest
for (int y = 0; y < keywh.y; ++y) //copying to it->h rows in dest; vert scaling is more likely, so make Y the inner loop for better pixel caching
{
// static xlColor cached_rgb; //cached mapped pixel color
// static wxPoint cached_xy(-1, -1);
wxPoint src_xy(sprite->xy[drawstate].x + x * xscale, sprite->xy[drawstate].y + y * yscale);
//TODO: scale doesn't make sense for all cases
src_xy.y = Shapes.GetHeight() - src_xy.y - 1; //whoops, origin is top left but wanted bottom left
bool transparent = 0;
if (WantHistory(style)) cached_rgb = drawstate? sprite->on: sprite->off; //kludge: fill rect with same color to avoid losing pixels due to scaling
else if ((src_xy.x != cached_xy.x) || (src_xy.y != cached_xy.y)) //update cached pixel info
{
cached_xy = src_xy; //prev_xy.x = src_xy.x; prev_y = srcy; //not sure how expensive wx pixel functions are, so cache current pixel info just in case; aliasing/averaging and color mapping also makes thiss more expensive
if (Shapes.IsTransparent(src_xy.x, src_xy.y)) transparent = 1; //-1; //-1 matches white, so use + instead
else
{
// xlColor c;
//TODO: tile, center, anti-aliasing
cached_rgb.Set(Shapes.GetRed(src_xy.x, src_xy.y), Shapes.GetGreen(src_xy.x, src_xy.y), Shapes.GetBlue(src_xy.x, src_xy.y)); //NOTE: need to do pixel merging if scale is not 1:1
if (!ColorMap.empty()) cached_rgb = ColorMap[cached_rgb.GetRGB()]; //map to user-selected colors
}
debug_more(20, ", LK(%d,%d)", cached_xy.x, cached_xy.y);
}
if (transparent == 1 /*-1*/) continue; //don't need to draw pixel
int wrapx = sprite->destxy.x + x, scrolly = sprite->destxy.y;
// if (style == PIANO_STYLE_ANIMAGE) { wrapx *= xscale; scrolly *= yscale; }
if (!clip) wrapx %= canvas.x; //wrap on even key boundary
// if ((style == PIANO_STYLE_ICICLES) || (style == PIANO_STYLE_EQBARS)) scrolly += canvas.y - keywh.y; //draw at top instead of bottom
if (style == PIANO_STYLE_ICICLES) scrolly += canvas.y - keywh.y; //draw at top instead of bottom
// debug_more(20, ", %d+%d vs. %d-%d? %d", xofs, wrapx, BufferWi, xofs, xofs + wrapx < BufferWi - xofs);
// if (!clip) wrapx = (wrapx + 2 * xofs) % BufferWi - 2 * xofs; //wrap within reduced area, not expanded area
debug_more(20, ", (%d,%d)<-0x%x", wrapx, sprite->destxy.y + y, cached_rgb.GetRGB());
if (xofs + wrapx < buffer.BufferWi - xofs) buffer.SetPixel(xofs + wrapx, sprite->destxy.y + y, cached_rgb); //no vertical wrap, only horizontal wrap
}
// debug.Flush(true);
return true;
}
void RenderBuffer::SetTempPixel(int x, int y, const xlColor & color, int alpha)
{
xlColor c(color.Red(), color.Green(), color.Blue(), alpha);
SetTempPixel(x, y, c);
}
void RenderBuffer::Get2ColorAlphaBlend(const xlColor& c1, const xlColor& c2, float ratio, xlColor &color)
{
color.Set(ChannelBlend(c1.Red(),c2.Red(),ratio), ChannelBlend(c1.Green(),c2.Green(),ratio), ChannelBlend(c1.Blue(),c2.Blue(),ratio));
}
void RenderBuffer::Get2ColorBlend(xlColor& color, xlColor color2, float ratio)
{
color.Set(ChannelBlend(color.Red(), color2.Red(), ratio), ChannelBlend(color.Green(), color2.Green(), ratio), ChannelBlend(color.Blue(), color2.Blue(), ratio));
}
void RenderBuffer::Color2HSV(const xlColor& color, HSVValue& hsv)
{
color.toHSV(hsv);
}
void TextDrawingContext::SetFont(wxFontInfo &font, const xlColor &color) {
if (gc != nullptr) {
int style = wxFONTFLAG_NOT_ANTIALIASED;
if (font.GetWeight() == wxFONTWEIGHT_BOLD) {
style |= wxFONTFLAG_BOLD;
}
if (font.GetWeight() == wxFONTWEIGHT_LIGHT) {
style |= wxFONTFLAG_LIGHT;
}
if (font.GetStyle() == wxFONTSTYLE_ITALIC) {
style |= wxFONTFLAG_ITALIC;
}
if (font.GetStyle() == wxFONTSTYLE_SLANT) {
style |= wxFONTFLAG_SLANT;
}
if (font.IsUnderlined()) {
style |= wxFONTFLAG_UNDERLINED;
}
if (font.IsStrikethrough()) {
style |= wxFONTFLAG_STRIKETHROUGH;
}
if (style != fontStyle
|| font.GetPixelSize().y != fontSize
|| font.GetFaceName() != fontName
|| color != fontColor) {
this->font = gc->CreateFont(font.GetPixelSize().y, font.GetFaceName(), style, color.asWxColor());
fontStyle = style;
fontSize = font.GetPixelSize().y;
fontName = font.GetFaceName();
fontColor = color;
}
gc->SetFont(this->font);
} else {
wxFont f(font);
#ifdef __WXMSW__
/*
Here is the format for NativeFontInfo on Windows (taken from the source)
We want to change lfQuality from 2 to 3 - this disables antialiasing
s.Printf(wxS("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
0, // version, in case we want to change the format later
lf.lfHeight,
lf.lfWidth,
lf.lfEscapement,
lf.lfOrientation,
lf.lfWeight,
lf.lfItalic,
lf.lfUnderline,
lf.lfStrikeOut,
lf.lfCharSet,
lf.lfOutPrecision,
lf.lfClipPrecision,
lf.lfQuality,
lf.lfPitchAndFamily,
lf.lfFaceName);*/
wxString s = f.GetNativeFontInfoDesc();
s.Replace(";2;",";3;",false);
f.SetNativeFontInfo(s);
#endif
dc->SetFont(f);
dc->SetTextForeground(color.asWxColor());
}
}
void DrawGLUtils::DrawRectangle(const xlColor &color, bool dashed, int x1, int y1, int x2, int y2)
{
glColor3ub(color.Red(), color.Green(),color.Blue());
if (!dashed)
{
glBegin(GL_LINES);
glVertex2f(x1, y1);
glVertex2f(x2, y1);
glVertex2f(x2, y1);
glVertex2f(x2, y2 - 0.4f);
glVertex2f(x2, y2 - 0.4f);
glVertex2f(x1, y2 - 0.4f);
glVertex2f(x1, y1);
glVertex2f(x1, y2);
glEnd();
}
else
{
glBegin(GL_POINTS);
// Line 1
int xs = x1<x2?x1:x2;
int xf = x1>x2?x1:x2;
for(int x=xs;x<=xf;x++)
{
if(x%8<4)
{
glVertex2f(x, y1);
}
}
// Line 2
int ys = y1<y2?y1:y2;
int yf = y1>y2?y1:y2;
for(int y=ys;y<=yf;y++)
{
if(y%8<4)
{
glVertex2f(x2,y);
}
}
// Line 3
xs = x1<x2?x1:x2;
xf = x1>x2?x1:x2;
for(int x=xs;x<=xf;x++)
{
if(x%8<4)
{
glVertex2f(x, y2);
}
}
// Line 4
ys = y1<y2?y1:y2;
yf = y1>y2?y1:y2;
for(int y=ys;y<=yf;y++)
{
if(y%8<4)
{
glVertex2f(x1,y);
}
}
glEnd();
}
}
void DrawGLUtils::DrawCircle(const xlColor &color, double cx, double cy, double r, int ctransparency, int etransparency)
{
if (ctransparency) {
double t = 100.0 - ctransparency;
t *= 2.56;
ctransparency = t;
glColor4ub(color.Red(), color.Green(),color.Blue(), ctransparency);
} else {
glColor3ub(color.Red(), color.Green(),color.Blue());
}
int num_segments = r / 2;
if (num_segments < 16) {
num_segments = 16;
}
float theta = 2 * 3.1415926 / float(num_segments);
float tangetial_factor = tanf(theta);//calculate the tangential factor
float radial_factor = cosf(theta);//calculate the radial factor
float x = r;//we start at angle = 0
float y = 0;
glBegin(GL_TRIANGLE_FAN);
glVertex2f(cx, cy); //center vertex
if (etransparency) {
double t = 100.0 - etransparency;
t *= 2.56;
etransparency = t;
glColor4ub(color.Red(), color.Green(),color.Blue(), etransparency);
} else {
glColor3ub(color.Red(), color.Green(),color.Blue());
}
for(int ii = 0; ii < num_segments; ii++)
{
glVertex2f(x + cx, y + cy);//output vertex
//calculate the tangential vector
//remember, the radial vector is (x, y)
//to get the tangential vector we flip those coordinates and negate one of them
float tx = -y;
float ty = x;
//add the tangential vector
x += tx * tangetial_factor;
y += ty * tangetial_factor;
//correct using the radial factor
x *= radial_factor;
y *= radial_factor;
}
glVertex2f(x + cx, y + cy);//output vertex
glEnd();
}
xlColor PixelBufferClass::mixColors(const wxCoord &x, const wxCoord &y, const xlColor &fg, const xlColor &c1, int layer)
{
static const int n = 0; //increase to change the curve of the crossfade
xlColor c0 = fg;
HSVValue hsv0;
HSVValue hsv1;
bool handlesAlpha = MixTypeHandlesAlpha(layers[layer]->mixType);
if (!handlesAlpha && layers[layer]->fadeFactor != 1.0)
{
//need to fade the first here as we're not mixing anything
hsv0 = c0.asHSV();
hsv0.value *= layers[layer]->fadeFactor;
c0 = hsv0;
}
float svthresh = layers[layer]->effectMixThreshold;
if (layers[layer]->effectMixVaries)
{
//vary mix threshold gradually during effect interval -DJ
layers[layer]->effectMixThreshold = layers[layer]->buffer.GetEffectTimeIntervalPosition();
}
if (layers[layer]->effectMixThreshold < 0)
{
layers[layer]->effectMixThreshold = 0;
}
xlColor c;
double emt, emtNot;
switch (layers[layer]->mixType)
{
case Mix_Normal:
c0.alpha = c0.alpha * layers[layer]->fadeFactor * (1.0 - layers[layer]->effectMixThreshold);
c = c0.AlphaBlend(c1);
break;
case Mix_Effect1:
case Mix_Effect2:
{
if (!layers[layer]->effectMixVaries)
{
emt = layers[layer]->effectMixThreshold;
if ((emt > 0.000001) && (emt < 0.99999))
{
emtNot = 1-layers[layer]->effectMixThreshold;
//make cross-fade linear
emt = cos((M_PI/4)*(pow(2*emt-1,2*n+1)+1));
emtNot = cos((M_PI/4)*(pow(2*emtNot-1,2*n+1)+1));
}
else
{
emtNot = layers[layer]->effectMixThreshold;
emt = 1 - layers[layer]->effectMixThreshold;
}
}
else
{
emt = layers[layer]->effectMixThreshold;
emtNot = 1-layers[layer]->effectMixThreshold;
}
xlColor c2(c1);
if (layers[layer]->mixType == Mix_Effect2)
{
c0.Set(c0.Red()*(emtNot),c0.Green()*(emtNot), c0.Blue()*(emtNot));
c2.Set(c1.Red()*(emt),c1.Green()*(emt), c1.Blue()*(emt));
}
else
{
c0.Set(c0.Red()*(emt),c0.Green()*(emt), c0.Blue()*(emt));
c2.Set(c1.Red()*(emtNot),c1.Green()*(emtNot), c1.Blue()*(emtNot));
}
c.Set(c0.Red()+c2.Red(), c0.Green()+c2.Green(), c0.Blue()+c2.Blue());
break;
}
case Mix_Mask1:
// first masks second
hsv0 = c0.asHSV();
if (hsv0.value <= layers[layer]->effectMixThreshold)
{
// only if effect 1 is black
c=c1; // then show the color of effect 2
}
else
{
c.Set(0, 0, 0);
}
break;
case Mix_Mask2:
// second masks first
hsv1 = c1.asHSV();
if (hsv1.value <= layers[layer]->effectMixThreshold)
{
c=c0;
}
else
{
c.Set(0, 0, 0);
}
break;
case Mix_Unmask1:
// first unmasks second
c0.toHSV(hsv0);
c1.toHSV(hsv1);
if (hsv0.value > layers[layer]->effectMixThreshold)
{
// if effect 1 is non black
hsv1.value = hsv0.value;
c = hsv1;
}
else
{
c.Set(0, 0, 0);
}
break;
case Mix_Unmask2:
// second unmasks first
c0.toHSV(hsv0);
c1.toHSV(hsv1);
if (hsv1.value > layers[layer]->effectMixThreshold)
{
// if effect 2 is non black
hsv0.value = hsv1.value;
c = hsv0;
}
else
{
c.Set(0, 0, 0);
}
break;
case Mix_Shadow_1on2:
// Effect 1 shadows onto effect 2
c0.toHSV(hsv0);
c1.toHSV(hsv1);
// if (hsv0.value > effectMixThreshold[layer]) {
// if effect 1 is non black
// to shadow we will shift the hue on the primary layer using the hue and brightness from the
// other layer
if(hsv0.value>0.0) hsv1.hue = hsv1.hue + (hsv0.value*(hsv1.hue-hsv0.hue))/5.0;
// hsv1.value = hsv0.value;
//hsv1.saturation = hsv0.saturation;
c = hsv1;
// }
break;
case Mix_Shadow_2on1:
// Effect 2 shadows onto effect 1
c0.toHSV(hsv0);
c1.toHSV(hsv1);
//if (hsv1.value > effectMixThreshold[layer]) {
// if effect 1 is non black
if(hsv1.value>0.0) hsv0.hue = hsv0.hue + (hsv1.value*(hsv0.hue-hsv1.hue))/2.0;
//hsv0.value = hsv1.value;
//hsv0.saturation = hsv1.saturation;
c = hsv0;
// }
break;
case Mix_Layered:
c1.toHSV(hsv1);
if (hsv1.value <= layers[layer]->effectMixThreshold)
{
c=c0;
}
else
{
c=c1;
}
break;
case Mix_Average:
// only average when both colors are non-black
if (c0 == xlBLACK)
{
c=c1;
}
else if (c1 == xlBLACK)
{
c=c0;
}
else
{
c.Set( (c0.Red()+c1.Red())/2, (c0.Green()+c1.Green())/2, (c0.Blue()+c1.Blue())/2 );
}
break;
case Mix_BottomTop:
c= y < layers[layer]->BufferHt/2 ? c0 : c1;
break;
case Mix_LeftRight:
c= x < layers[layer]->BufferWi/2 ? c0 : c1;
break;
case Mix_1_reveals_2:
c0.toHSV(hsv0);
c = hsv0.value > layers[layer]->effectMixThreshold ? c0 : c1; // if effect 1 is non black
break;
case Mix_2_reveals_1:
c1.toHSV(hsv1);
c = hsv1.value > layers[layer]->effectMixThreshold ? c1 : c0; // if effect 2 is non black
break;
}
if (layers[layer]->effectMixVaries)
{
layers[layer]->effectMixThreshold = svthresh; //put it back afterwards in case next row didn't change it
}
return c;
}
