1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*
* Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
* Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
* Copyright (c) 2004 Clarence Dang <dang@kde.org>
* Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
* Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <tqrect.h>
#include <kdebug.h>
#include "kis_vec.h"
#include "kis_brush.h"
#include "kis_global.h"
#include "kis_paint_device.h"
#include "kis_painter.h"
#include "kis_types.h"
#include "kis_paintop.h"
#include "kis_layer.h"
#include "kis_selection.h"
#include "kis_airbrushop.h"
KisPaintOp * KisAirbrushOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisAirbrushOp(painter);
TQ_CHECK_PTR(op);
return op;
}
KisAirbrushOp::KisAirbrushOp(KisPainter * painter)
: super(painter)
{
}
KisAirbrushOp::~KisAirbrushOp()
{
}
void KisAirbrushOp::paintAt(const KisPoint &pos, const KisPaintInformation& info)
{
// See: http://www.sysf.physto.se/~klere/airbrush/ for information
// about _real_ airbrushes.
//
// Most graphics apps -- especially the simple ones like Kolourpaint
// and the previous version of this routine in Chalk took a brush
// shape -- often a simple ellipse -- and filled that shape with a
// random 'spray' of single pixels.
//
// Other, more advanced graphics apps, like the Gimp or Photoshop,
// take the brush shape and paint just as with the brush paint op,
// only making the initial dab more transparent, and perhaps adding
// extra transparence near the edges. Then, using a timer, when the
// cursor stays in place, dab upon dab is positioned in the same
// place, which makes the result less and less transparent.
//
// What I want to do here is create an airbrush that approaches a real
// one. It won't use brush shapes, instead going for the old-fashioned
// circle. Depending upon pressure, both the size of the dab and the
// rate of paint deposition is determined. The edges of the dab are
// more transparent than the center, with perhaps even some fully
// transparent pixels between the near-transparent pixels.
//
// By pressing some to-be-determined key at the same time as pressing
// mouse-down, one edge of the dab is made straight, to simulate
// working with a shield.
//
// Tilt may be used to make the gradients more realistic, but I don't
// have a tablet that supports tilt.
//
// Anyway, it's exactly twenty years ago that I have held a real
// airbrush, for the first and up to now the last time...
//
if (!m_painter) return;
KisPaintDeviceSP device = m_painter->device();
// For now: use the current brush shape -- it beats calculating
// ellipes and cones, and it shows the working of the timer.
if (!device) return;
KisBrush * brush = m_painter->brush();
if (! brush->canPaintFor(info) )
return;
KisPaintDeviceSP dab = m_painter->dab();
KisPoint hotSpot = brush->hotSpot(info);
KisPoint pt = pos - hotSpot;
TQ_INT32 x;
double xFraction;
TQ_INT32 y;
double yFraction;
splitCoordinate(pt.x(), &x, &xFraction);
splitCoordinate(pt.y(), &y, &yFraction);
if (brush->brushType() == IMAGE || brush->brushType() == PIPE_IMAGE) {
dab = brush->image(device->colorSpace(), info, xFraction, yFraction);
}
else {
KisAlphaMaskSP mask = brush->mask(info, xFraction, yFraction);
dab = computeDab(mask);
}
m_painter->setDab(dab); // Cache dab for future paints in the painter.
m_painter->setPressure(info.pressure); // Cache pressure in the current painter.
TQRect dabRect = TQRect(0, 0, brush->maskWidth(info), brush->maskHeight(info));
TQRect dstRect = TQRect(x, y, dabRect.width(), dabRect.height());
KisImage * image = device->image();
if (image != 0) {
dstRect &= image->bounds();
}
if (dstRect.isNull() || dstRect.isEmpty() || !dstRect.isValid()) return;
TQ_INT32 sx = dstRect.x() - x;
TQ_INT32 sy = dstRect.y() - y;
TQ_INT32 sw = dstRect.width();
TQ_INT32 sh = dstRect.height();
if (m_source->hasSelection()) {
m_painter->bltSelection(dstRect.x(), dstRect.y(), m_painter->compositeOp(), dab.data(),
m_source->selection(), m_painter->opacity(), sx, sy, sw, sh);
}
else {
m_painter->bitBlt(dstRect.x(), dstRect.y(), m_painter->compositeOp(), dab.data(), m_painter->opacity(), sx, sy, sw, sh);
}
m_painter->addDirtyRect(dstRect);
}
|
