?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use USER_CPPFLAGS
[AROS.git] / arch / all-native / hidd / vgagfx / vgagfx_bitmapclass.c
bloba754d5e65ca37a56d4c351e9747fd8d301db4a38
1 /*
2 Copyright © 1995-2013, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Bitmap class for VGA Hidd.
6 Lang: English.
7 */
8
9 #define SDEBUG 0
10 #define DEBUG 0
11 #include <aros/debug.h>
12
13 #define __OOP_NOATTRBASES__
14
15 #include <proto/oop.h>
16 #include <proto/utility.h>
17
18 #include <exec/memory.h>
19 #include <exec/lists.h>
20
21 #include <graphics/rastport.h>
22 #include <graphics/gfx.h>
23 #include <oop/oop.h>
24
25 #include <aros/symbolsets.h>
26
27 #include <hidd/gfx.h>
28
29 #include <assert.h>
30
31 #include "vgagfx_support.h"
32
33 #include LC_LIBDEFS_FILE
34
35 void vgaRestore(struct vgaHWRec *);
36 int vgaInitMode(struct vgaModeDesc *, struct vgaHWRec *);
37 void vgaLoadPalette(struct vgaHWRec *, unsigned char *);
38
39 #define MNAME_ROOT(x) VGAGfxBM__Root__ ## x
40 #define MNAME_BM(x) VGAGfxBM__Hidd_BitMap__ ## x
41
42 /*********** BitMap::New() *************************************/
43
44 OOP_Object *VGAGfxBM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
45 {
46 EnterFunc(bug("VGAGfx.BitMap::New()\n"));
47
48 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
49 D(bug("[VGAGfx:BitMap] Object created by superclass: 0x%p\n"));
50 if (o)
51 {
52 struct VGAGfxBitMapData *data;
53 OOP_Object *gfxhidd, *sync, *pf;
54 IPTR modeid = vHidd_ModeID_Invalid;
55 IPTR width, height, depth;
56 IPTR dwidth, dheight;
57 IPTR displayable = FALSE;
58
59 data = OOP_INST_DATA(cl, o);
60
61 /* clear all data */
62 memset(data, 0, sizeof(struct VGAGfxBitMapData));
63
64 /* Get attr values */
65 OOP_GetAttr(o, aHidd_BitMap_ModeID , &modeid );
66 OOP_GetAttr(o, aHidd_BitMap_Width , &width );
67 OOP_GetAttr(o, aHidd_BitMap_Height , &height );
68 OOP_GetAttr(o, aHidd_BitMap_Displayable, &displayable);
69 OOP_GetAttr(o, aHidd_BitMap_PixFmt , (IPTR *)&pf );
70 D(bug("[VGAGfx:BitMap] PixFmt object: 0x%p\n", pf));
71 OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
72
73 D(bug("[VGAGfx:BitMap] Size: %lux%lu, depth: %lu\n", width, height, depth));
74 D(bug("[VGAGfx:BitMap] Displayable: %ld\n", displayable));
75 ASSERT (width != 0 && height != 0 && depth != 0);
76
77 data->width = width;
78 data->height = height;
79 data->bpp = depth;
80
81 if (modeid != vHidd_ModeID_Invalid) {
82
83 OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *)&gfxhidd);
84 HIDD_Gfx_GetMode(gfxhidd, modeid, &sync, &pf);
85 OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
86 OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
87 data->disp_width = dwidth;
88 data->disp_height = dheight;
89 D(bug("[VGAGfx:BitMap] Display size: %dx%d\n", dwidth, dheight));
90 }
91
92 width=(width+15) & ~15;
93 data->bpr = width;
94 data->VideoData = AllocVec(width*height,MEMF_PUBLIC|MEMF_CLEAR);
95 D(bug("[VGAGfx:BitMap] Allocated videodata at 0x%p\n", data->VideoData));
96 if (data->VideoData) {
97 struct TagItem tags[2];
98
99 tags[0].ti_Tag = aHidd_ChunkyBM_Buffer;
100 tags[0].ti_Data = (IPTR)data->VideoData;
101 tags[1].ti_Tag = TAG_END;
102 OOP_SetAttrs(o, tags);
103
104 /* If the bitmap is not displayable, we're done */
105 if (!displayable)
106 ReturnPtr("VGAGfx.BitMap::New()", OOP_Object *, o);
107
108 data->Regs = AllocVec(sizeof(struct vgaHWRec),MEMF_PUBLIC|MEMF_CLEAR);
109 D(bug("[VGAGfx:BitMap] Registers at 0x%p\n", data->Regs));
110 /*
111 Here there is brand new method of getting pixelclock data.
112 It was introduced here to make the code more portable. Besides
113 it may now be used as a base for creating other low level
114 video drivers
115 */
116 if (data->Regs) {
117 struct vgaModeDesc mode;
118 IPTR pixelc;
119
120 /* We should have got modeID from the bitmap */
121 if (modeid != vHidd_ModeID_Invalid)
122 {
123 mode.Width = dwidth;
124 mode.Height = dheight;
125 mode.Depth = depth;
126 OOP_GetAttr(sync, aHidd_Sync_PixelClock, &pixelc);
127
128 mode.clock = (pixelc > 26000000) ? 1 : 0;
129 mode.Flags = 0;
130 mode.HSkew = 0;
131 OOP_GetAttr(sync, aHidd_Sync_HDisp, &mode.HDisplay);
132 OOP_GetAttr(sync, aHidd_Sync_VDisp, &mode.VDisplay);
133 OOP_GetAttr(sync, aHidd_Sync_HSyncStart, &mode.HSyncStart);
134 OOP_GetAttr(sync, aHidd_Sync_VSyncStart, &mode.VSyncStart);
135 OOP_GetAttr(sync, aHidd_Sync_HSyncEnd, &mode.HSyncEnd);
136 OOP_GetAttr(sync, aHidd_Sync_VSyncEnd, &mode.VSyncEnd);
137 OOP_GetAttr(sync, aHidd_Sync_HTotal, &mode.HTotal);
138 OOP_GetAttr(sync, aHidd_Sync_VTotal, &mode.VTotal);
139
140 vgaInitMode(&mode, data->Regs);
141 vgaLoadPalette(data->Regs,(unsigned char *)NULL);
142
143 D(bug("[VGAGfx:BitMap] Created displayable bitmap 0x%p, data 0x%p\n", o, data));
144 return o;
145 }
146 }
147 FreeVec(data->VideoData);
148 }
149
150 {
151 OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
152 OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
153 }
154
155 o = NULL;
156 } /* if created object */
157
158 ReturnPtr("VGAGfx.BitMap::New()", OOP_Object *, o);
159 }
160
161 /********** Bitmap::Dispose() ***********************************/
162
163 VOID VGAGfxBM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
164 {
165 struct VGAGfxBitMapData *data = OOP_INST_DATA(cl, o);
166 EnterFunc(bug("VGAGfx.BitMap::Dispose()\n"));
167
168 FreeVec(data->VideoData);
169 FreeVec(data->Regs);
170
171 OOP_DoSuperMethod(cl, o, msg);
172
173 ReturnVoid("VGAGfx.BitMap::Dispose");
174 }
175
176 /********* BitMap::SetColors() ***************************/
177
178 void vgaDACLoad(struct vgaHWRec *, unsigned char, int);
179
180 BOOL MNAME_BM(SetColors)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
181 {
182 struct VGAGfxBitMapData *data = OOP_INST_DATA(cl, o);
183 HIDDT_PixelFormat *pf;
184
185 ULONG xc_i, col_i;
186
187 HIDDT_Pixel red, green, blue;
188
189 pf = BM_PIXFMT(o);
190
191 if ( vHidd_ColorModel_StaticPalette == HIDD_PF_COLMODEL(pf)
192 || vHidd_ColorModel_TrueColor == HIDD_PF_COLMODEL(pf) ) {
193
194 /* Superclass takes care of this case */
195
196 return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
197 }
198
199 /* We have a vHidd_GT_Palette bitmap */
200
201 if (!OOP_DoSuperMethod(cl, o, (OOP_Msg)msg)) return FALSE;
202 if (!data->Regs)
203 return TRUE;
204
205 if ((msg->firstColor + msg->numColors) > (1 << data->bpp))
206 return FALSE;
207
208
209 for ( xc_i = msg->firstColor, col_i = 0;
210 col_i < msg->numColors;
211 xc_i ++, col_i ++ )
212 {
213 red = msg->colors[col_i].red >> 8;
214 green = msg->colors[col_i].green >> 8;
215 blue = msg->colors[col_i].blue >> 8;
216
217 /* Update DAC registers */
218 data->Regs->DAC[xc_i*3] = red >> 2;
219 data->Regs->DAC[xc_i*3+1] = green >> 2;
220 data->Regs->DAC[xc_i*3+2] = blue >> 2;
221
222 msg->colors[col_i].pixval = xc_i;
223 }
224
225 /* Restore palette if displayed */
226 if (data->disp) {
227 ObtainSemaphore(&XSD(cl)->HW_acc);
228 vgaDACLoad(data->Regs, msg->firstColor, msg->numColors);
229 ReleaseSemaphore(&XSD(cl)->HW_acc);
230 }
231
232 return TRUE;
233 }
234
235 /********* BitMap::PutPixel() ***************************/
236 // FIXME: in theory we shouldn't need this method since the superclass implements it
237
238 VOID MNAME_BM(PutPixel)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPixel *msg)
239 {
240 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
241 return;
242 }
243
244 /*** BitMap::Set() *******************************************/
245
246 VOID MNAME_ROOT(Set)(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
247 {
248 struct VGAGfxBitMapData *data = OOP_INST_DATA(cl, o);
249 struct TagItem *tag, *tstate;
250 ULONG idx;
251 int limit;
252 int xoffset = data->xoffset;
253 int yoffset = data->yoffset;
254
255 tstate = msg->attrList;
256 while((tag = NextTagItem(&tstate)))
257 {
258 if(IS_BM_ATTR(tag->ti_Tag, idx))
259 {
260 switch(idx)
261 {
262 case aoHidd_BitMap_Visible:
263 data->disp = tag->ti_Data;
264 D(bug("[VGAGfx:BitMap] Visible set to %d\n", data->disp));
265 if (data->disp) {
266 struct Box box;
267
268 /* Program video mode on the card */
269 bug("\x03");
270 vgaRestore(data->Regs);
271 /* If our bitmap is smaller than display area,
272 we need to clear two rectangles: to the right
273 and to the bottom of the used framebuffer
274 portion */
275 if (data->disp_width > data->width) {
276 box.x1 = data->width;
277 box.y1 = 0;
278 box.x2 = data->disp_width - 1;
279 box.y2 = data->height - 1;
280 vgaEraseArea(data, &box);
281 }
282 if (data->disp_height > data->height) {
283 box.x1 = 0;
284 box.y1 = data->height;
285 box.x2 = data->width - 1;
286 box.y2 = data->disp_height - 1;
287 vgaEraseArea(data, &box);
288 }
289 }
290 break;
291 case aoHidd_BitMap_LeftEdge:
292 xoffset = tag->ti_Data;
293 limit = data->disp_width - data->width;
294 if (xoffset > 0)
295 xoffset = 0;
296 else if (xoffset < limit)
297 xoffset = limit;
298 break;
299 case aoHidd_BitMap_TopEdge:
300 yoffset = tag->ti_Data;
301 limit = data->disp_height - data->height;
302 if (yoffset > 0)
303 yoffset = 0;
304 else if (yoffset < limit)
305 yoffset = limit;
306 break;
307 }
308 }
309 }
310 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
311
312 if ((xoffset != data->xoffset) || (yoffset != data->yoffset)) {
313 data->xoffset = xoffset;
314 data->yoffset = yoffset;
315
316 if (data->disp) {
317 struct Box box = {0, 0, data->disp_width - 1, data->disp_height - 1};
318
319 ObtainSemaphore(&XSD(cl)->HW_acc);
320 vgaRefreshArea(data, &box);
321 draw_mouse(XSD(cl));
322 ReleaseSemaphore(&XSD(cl)->HW_acc);
323 }
324 }
325 }
326
327 VOID MNAME_ROOT(Get)(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
328 {
329 struct VGAGfxBitMapData *data = OOP_INST_DATA(cl, o);
330 ULONG idx;
331
332 if (IS_VGABM_ATTR(msg->attrID, idx)) {
333 switch (idx) {
334 case aoHidd_VGABitMap_Drawable:
335 *msg->storage = (IPTR)data->VideoData;
336 return;
337 }
338 } else if (IS_BM_ATTR(msg->attrID, idx)) {
339 switch (idx) {
340 case aoHidd_BitMap_LeftEdge:
341 *msg->storage = data->xoffset;
342 return;
343 case aoHidd_BitMap_TopEdge:
344 *msg->storage = data->yoffset;
345 return;
346 case aoHidd_BitMap_Visible:
347 *msg->storage = data->disp;
348 return;
349 }
350 }
351 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
352 }
353
354 /*** BitMap::UpdateRect() *******************************************/
355
356 VOID VGAGfxBM__Hidd_BitMap__UpdateRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg)
357 {
358 struct VGAGfxBitMapData *data = OOP_INST_DATA(cl, o);
359 int left = msg->x + data->xoffset;
360 int top = msg->y + data->yoffset;
361 int right = left + msg->width - 1;
362 int bottom = top + msg->height - 1;
363
364 if ((right < 0) || (bottom < 0))
365 return;
366 if (left < 0)
367 left = 0;
368 if (top < 0)
369 top = 0;
370
371 if (data->disp)
372 {
373 ObtainSemaphore(&XSD(cl)->HW_acc);
374
375 if ((msg->width == 1) && (msg->height == 1))
376 vgaRefreshPixel(data, left, top);
377 else {
378 struct Box box = {left, top, right, bottom};
379
380 vgaRefreshArea(data, &box);
381 }
382
383 if ( ( (XSD(cl)->mouseX + XSD(cl)->mouseW - 1 >= left) &&
384 (XSD(cl)->mouseX <= right) ) ||
385 ( (XSD(cl)->mouseY + XSD(cl)->mouseH - 1 >= top) &&
386 (XSD(cl)->mouseY <= bottom) ) )
387 draw_mouse(XSD(cl));
388
389 ReleaseSemaphore(&XSD(cl)->HW_acc);
390 }
391 }
Mirror of AROS' svn.