38 |
38 |
39 ~HgQtImage() |
39 ~HgQtImage() |
40 { |
40 { |
41 } |
41 } |
42 |
42 |
43 int width() const |
43 int width() const { |
44 { |
|
45 return mPixmap.width(); |
44 return mPixmap.width(); |
46 } |
45 } |
47 |
46 |
48 int height() const |
47 int height() const { |
49 { |
|
50 return mPixmap.height(); |
48 return mPixmap.height(); |
51 } |
49 } |
52 |
50 |
53 int mirrorImageWidth() const |
51 int mirrorPixmapWidth() const { |
54 { |
52 return mMirrorPixmap.width(); |
55 return width(); |
53 } |
56 } |
54 |
57 |
55 int mirrorPixmapHeight() const { |
58 int mirrorImageHeight() const |
56 return mMirrorPixmap.height(); |
59 { |
57 } |
60 return height(); |
58 |
61 } |
59 void setPixmap(const QPixmap& pixmap, bool createMirror) { |
62 |
60 mPixmap = pixmap; |
63 void setImage(const QImage& image) |
61 if (createMirror) { |
64 { |
62 createMirrorPixmap(mPixmap); |
65 mPixmap = QPixmap::fromImage(image); |
63 } else { |
66 //mMirrorPixmap = QPixmap(); |
64 mMirrorPixmap = QPixmap(); |
67 } |
65 } |
68 |
66 } |
69 void setPixmap(const QPixmap& pixmap) |
67 |
70 { |
68 void releaseImages() { |
71 mPixmap = pixmap; |
69 mPixmap = QPixmap(); |
72 //mMirrorPixmap = QPixmap(); |
70 mMirrorPixmap = QPixmap(); |
73 } |
71 } |
74 |
72 |
75 void releaseImage() |
73 QPixmap pixmap() const { |
76 { |
|
77 //mPixmap = QPixmap(); |
|
78 //mMirrorPixmap = QPixmap(); |
|
79 } |
|
80 |
|
81 QImage getQImage() const |
|
82 { |
|
83 return mPixmap.toImage(); |
|
84 } |
|
85 |
|
86 const QPixmap& pixmap() const |
|
87 { |
|
88 return mPixmap; |
74 return mPixmap; |
89 } |
75 } |
90 |
76 |
91 const QPixmap& mirrorPixmap(QPainter* painter) |
77 QPixmap mirrorPixmap() { |
92 { |
78 return mMirrorPixmap; |
93 Q_UNUSED(painter) |
79 } |
94 |
80 |
95 return mPixmap; |
81 void setMirrorPixmap(const QPixmap& mirrorPixmap) { |
96 /* |
82 mMirrorPixmap = mirrorPixmap; |
97 if (mPixmap.isNull()) |
83 } |
98 return mPixmap; |
84 |
99 |
85 void createMirrorPixmap(const QPixmap& source) { |
100 if (mMirrorPixmap.isNull()) |
86 if (!source.isNull()) { |
101 { |
87 mMirrorPixmap = source.copy(QRect(0,source.height()*ReflectionHeight,source.width(),source.height())); |
102 QImage img = mPixmap.toImage(); |
88 QPainter painter(&mMirrorPixmap); |
103 QImage mirrorImage = img.scaled(QSize(img.width()/3,img.height()/3)).convertToFormat(QImage::Format_ARGB32); |
89 painter.setCompositionMode(QPainter::CompositionMode_DestinationIn); |
104 |
90 QLinearGradient gradient(0.5,0.0,0.5,1); |
105 // apply gradient to alpha channel so that mirror image looks like |
91 gradient.setCoordinateMode(QGradient::ObjectBoundingMode); |
106 // it fades under the floor |
92 gradient.setColorAt(1, QColor::fromRgb(0,0,0,128)); |
107 for (int i = 0; i < mirrorImage.height(); i++) |
93 gradient.setColorAt(0, QColor::fromRgb(0,0,0,0)); |
108 { |
94 QBrush brush(gradient); |
109 qreal t = qreal(i) / qreal(mirrorImage.height()); |
95 painter.setBrush(brush); |
110 int a = (int)(t * 255.0); |
96 painter.setPen(Qt::NoPen); |
111 uchar* scanline = mirrorImage.scanLine(i); |
97 painter.drawRect(mMirrorPixmap.rect()); |
112 for (int j = 0; j < mirrorImage.width(); j++) |
98 } |
113 { |
99 } |
114 scanline[j*4+0] /= 3; |
100 |
115 scanline[j*4+1] /= 3; |
101 void updateMirror(bool enabled) { |
116 scanline[j*4+2] /= 3; |
102 if (enabled && !mPixmap.isNull() && mMirrorPixmap.isNull()) { |
117 scanline[j*4+3] = 255; |
103 createMirrorPixmap(mPixmap); |
118 } |
104 } else if(!enabled) { |
119 } |
105 mMirrorPixmap = QPixmap(); |
120 |
106 } |
121 mMirrorPixmap = QPixmap::fromImage(mirrorImage); |
107 } |
122 |
108 |
123 QPaintDevice* device = painter->device(); |
|
124 painter->end(); |
|
125 |
|
126 mMirrorPixmap = mPixmap.scaled(100,100); |
|
127 int w = mMirrorPixmap.width(); |
|
128 int h = mMirrorPixmap.height(); |
|
129 //QPainter p; |
|
130 painter->begin(&mMirrorPixmap); |
|
131 painter->fillRect(0,0,w, h, QColor::fromRgbF(0, 0, 0, 0.5f)); |
|
132 painter->end(); |
|
133 |
|
134 painter->begin(device); |
|
135 |
|
136 } |
|
137 |
|
138 |
|
139 return mMirrorPixmap;*/ |
|
140 } |
|
141 |
|
142 QPixmap mPixmap; |
109 QPixmap mPixmap; |
|
110 QPixmap mMirrorPixmap; |
143 }; |
111 }; |
144 |
112 |
145 class HgQtQuad : public HgTransformedQuad |
113 class HgQtQuad : public HgTransformedQuad |
146 { |
114 { |
147 public: |
115 public: |
196 QTransform::quadToQuad(img, poly, tm); |
164 QTransform::quadToQuad(img, poly, tm); |
197 } |
165 } |
198 |
166 |
199 void drawImage(QPainter* painter, HgQtImage* image, const QRectF& rect, const QTransform& transform) |
167 void drawImage(QPainter* painter, HgQtImage* image, const QRectF& rect, const QTransform& transform) |
200 { |
168 { |
201 const QPixmap& pixmap = image->pixmap(); |
169 QPixmap pixmap = image->pixmap(); |
202 |
170 |
203 if (pixmap.isNull()) |
171 if (pixmap.isNull()) |
204 return; |
172 return; |
205 |
173 |
|
174 |
206 const QVector2D* points = mTransformedPoints; |
175 const QVector2D* points = mTransformedPoints; |
207 if (mRenderer->isReflection() && quad()->mirrorImageEnabled()) |
176 if (mRenderer->isReflection() && quad()->mirrorImageEnabled()) { |
208 points = mMirroredPoints; |
177 points = mMirroredPoints; |
|
178 pixmap = image->mirrorPixmap(); |
|
179 } |
209 |
180 |
210 QPolygonF poly; |
181 QPolygonF poly; |
211 poly << points[0].toPointF(); |
182 poly << points[0].toPointF(); |
212 poly << points[1].toPointF(); |
183 poly << points[1].toPointF(); |
213 poly << points[2].toPointF(); |
184 poly << points[2].toPointF(); |
215 QRectF bounds = poly.boundingRect(); |
186 QRectF bounds = poly.boundingRect(); |
216 if (!(bounds.intersects(rect) || rect.contains(bounds))) { |
187 if (!(bounds.intersects(rect) || rect.contains(bounds))) { |
217 return; |
188 return; |
218 } |
189 } |
219 |
190 |
220 computeWarpMatrix(mTransform, image->width(), image->height(), points); |
191 computeWarpMatrix(mTransform, pixmap.width(), pixmap.height(), points); |
221 |
192 |
222 painter->setTransform(mTransform * transform); |
193 painter->setTransform(mTransform * transform); |
|
194 |
223 painter->drawPixmap(QPointF(0,0), pixmap); |
195 painter->drawPixmap(QPointF(0,0), pixmap); |
224 } |
196 } |
225 |
197 |
226 HgQtQuadRenderer* mRenderer; |
198 HgQtQuadRenderer* mRenderer; |
227 QTransform mTransform; |
199 QTransform mTransform; |
233 HgTransformedQuadRenderer(maxQuads), |
205 HgTransformedQuadRenderer(maxQuads), |
234 mDefaultQtImage(NULL) |
206 mDefaultQtImage(NULL) |
235 { |
207 { |
236 // initialize base class to the end. |
208 // initialize base class to the end. |
237 init(maxQuads); |
209 init(maxQuads); |
238 QImage image(QSize(200,200), QImage::Format_RGB16); |
210 QImage image(QSize(250,250), QImage::QImage::Format_ARGB32_Premultiplied); |
239 image.fill(0xFFFFFFFF); |
211 image.fill(0xFFFFFFFF); |
240 setDefaultImage(image); |
212 setDefaultImage(QPixmap::fromImage(image)); |
241 |
213 |
242 QPixmapCache::setCacheLimit(2048); |
214 QPixmapCache::setCacheLimit(2048); |
243 } |
215 } |
244 |
216 |
245 HgQtQuadRenderer::~HgQtQuadRenderer() |
217 HgQtQuadRenderer::~HgQtQuadRenderer() |
287 HgQtImage* HgQtQuadRenderer::defaultImage() |
259 HgQtImage* HgQtQuadRenderer::defaultImage() |
288 { |
260 { |
289 return mDefaultQtImage; |
261 return mDefaultQtImage; |
290 } |
262 } |
291 |
263 |
292 void HgQtQuadRenderer::setDefaultImage(QImage defaultImage) |
264 void HgQtQuadRenderer::setDefaultImage(QPixmap defaultImage) |
293 { |
265 { |
294 HgQuadRenderer::setDefaultImage(defaultImage); |
266 HgQuadRenderer::setDefaultImage(defaultImage); |
295 |
267 |
296 delete mDefaultQtImage; |
268 delete mDefaultQtImage; |
297 mDefaultQtImage = 0; |
269 mDefaultQtImage = 0; |
298 |
270 |
299 mDefaultQtImage = static_cast<HgQtImage*>(createNativeImage()); |
271 mDefaultQtImage = static_cast<HgQtImage*>(createNativeImage()); |
300 mDefaultQtImage->setImage(mDefaultImage); |
272 mDefaultQtImage->setPixmap(mDefaultImage, true); |
301 |
|
302 } |
273 } |
303 |
274 |
304 HgTransformedQuad* HgQtQuadRenderer::createNativeQuad() |
275 HgTransformedQuad* HgQtQuadRenderer::createNativeQuad() |
305 { |
276 { |
306 return new HgQtQuad(this); |
277 return new HgQtQuad(this); |