/* update and get brightness */
static int lm3630_bank_a_update_status(struct backlight_device *bl)
{
int ret;
struct lm3630_chip_data *pchip = bl_get_data(bl);
enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
/* brightness 0 means disable */
if (!bl->props.brightness) {
ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x04, 0x00);
if (ret < 0)
goto out;
return bl->props.brightness;
}
/* pwm control */
if (pwm_ctrl == PWM_CTRL_BANK_A || pwm_ctrl == PWM_CTRL_BANK_ALL) {
if (!set_intensity(bl, pchip))
dev_err(pchip->dev, "No pwm control func. in plat-data\n");
} else {
/* i2c control */
ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
if (ret < 0)
goto out;
mdelay(1);
ret = regmap_write(pchip->regmap,
REG_BRT_A, bl->props.brightness - 1);
if (ret < 0)
goto out;
}
return bl->props.brightness;
out:
dev_err(pchip->dev, "i2c failed to access REG_CTRL\n");
return bl->props.brightness;
}
static RefList *read_stream_reflections_2_3(FILE *fh, struct detector *det)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss, pk, bg;
char pn[32];
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %f %f %f %f %f %s",
&h, &k, &l, &intensity, &sigma, &pk, &bg,
&fs, &ss, pn);
if ( (r != 10) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 10 ) {
struct panel *p;
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
if ( det != NULL ) {
double write_fs, write_ss;
p = find_panel_by_name(det,pn);
write_fs = fs - p->orig_min_fs + p->min_fs;
write_ss = ss - p->orig_min_ss + p->min_ss;
set_detector_pos(refl, write_fs, write_ss);
}
set_esd_intensity(refl, sigma);
set_peak(refl, pk);
set_mean_bg(refl, bg);
set_redundancy(refl, 1);
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
/**
* \brief Merges the intensity of the color channels and the opacity of the
* element with a given color.
* \param c The color.
*/
void bear::visual::bitmap_rendering_attributes::colorize( color_type c )
{
const color_type::component_type component_max
( std::numeric_limits<color_type::component_type>::max() );
set_intensity
( get_red_intensity() * (double)c.components.red / component_max,
get_green_intensity() * (double)c.components.green / component_max,
get_blue_intensity() * (double)c.components.blue / component_max );
set_opacity( get_opacity() * (double)c.components.alpha / component_max );
} // bitmap_rendering_attributes::colorize()
static RefList *read_stream_reflections_2_1(FILE *fh)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss;
char phs[1024];
int cts;
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %s %f %i %f %f",
&h, &k, &l, &intensity, phs, &sigma, &cts, &fs, &ss);
if ( (r != 9) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 9 ) {
double ph;
char *v;
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
set_detector_pos(refl, 0.0, fs, ss);
set_esd_intensity(refl, sigma);
set_redundancy(refl, cts);
ph = strtod(phs, &v);
if ( v != phs ) set_phase(refl, deg2rad(ph));
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
/**
* \brief Combine with an other set of attributes.
* \param that The attributes to combine with.
*
* The attributes changed by this method are : is_flipped(), is_mirrored(), the
* intensities, the opacity and the angle. The size is not changed.
*/
void bear::visual::bitmap_rendering_attributes::combine
( const bitmap_rendering_attributes& that )
{
flip( that.is_flipped() ^ is_flipped() );
mirror( that.is_mirrored() ^ is_mirrored() );
set_intensity
( that.get_red_intensity() * get_red_intensity(),
that.get_green_intensity() * get_green_intensity(),
that.get_blue_intensity() * get_blue_intensity()
);
set_opacity( that.get_opacity() * get_opacity() );
set_angle( that.get_angle() + get_angle() );
} // bitmap_rendering_attributes::combine()
static RefList *read_stream_reflections(FILE *fh)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss, pk, bg;
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %f %f %f %f %f",
&h, &k, &l, &intensity, &sigma, &pk, &bg, &fs, &ss);
if ( (r != 9) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 9 ) {
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
set_detector_pos(refl, 0.0, fs, ss);
set_esd_intensity(refl, sigma);
set_redundancy(refl, 1);
set_peak(refl, pk);
set_mean_bg(refl, bg);
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
static int lm3630_bank_b_update_status(struct backlight_device *bl)
{
int ret;
struct lm3630_chip_data *pchip = bl_get_data(bl);
enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
if (pwm_ctrl == PWM_CTRL_BANK_B || pwm_ctrl == PWM_CTRL_BANK_ALL) {
if (!set_intensity(bl, pchip))
dev_err(pchip->dev,
"no pwm control func. in plat-data\n");
} else {
ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
if (ret < 0)
goto out;
mdelay(1);
ret = regmap_write(pchip->regmap,
REG_BRT_B, bl->props.brightness - 1);
}
return bl->props.brightness;
out:
dev_err(pchip->dev, "i2c failed to access register\n");
return bl->props.brightness;
}
//-----------------------------------------------------------------//
bool start(uint8_t limit = (CHAIN * 8)) noexcept {
if(limit_ > (8 * CHAIN) || limit == 0) {
return false;
}
limit_ = limit;
SELECT::DIR = 1; // output;
SELECT::PU = 0; // pull-up disable
SELECT::P = 1; // /CS = H
for(uint8_t i = 0; i < sizeof(data_); ++i) {
data_[i] = 0;
}
out_(command::SHUTDOWN, 0x01); // ノーマル・モード
out_(command::DECODE_MODE, 0x00); // デコード・モード
out_(command::SCAN_LIMIT, limit - 1); // 表示桁設定
set_intensity(0); // 輝度（最低）
service();
return true;
}
ProcessControls()
{
int xmax, ymax;
xmax = (layer[0].sizex * 16) - sx;
ymax = (layer[0].sizey * 16) - sy;
if (key[SCAN_F5]) { key[SCAN_F5]=0; ShellMAP(); }
if (key[SCAN_F6]) { key[SCAN_F6]=0; CompileAll(); }
if (key[SCAN_F8]) { key[SCAN_F8]=0; ShellVERGE(); }
if (key[SCAN_ALT] && key[SCAN_D]) { key[SCAN_D]=0; ShellToDOS(); }
if (key[SCAN_ALT] && key[SCAN_L]) LoadMAPDialog();
if (key[SCAN_ALT] && key[SCAN_V]) ShellEditMAP();
if (key[SCAN_ALT] && key[SCAN_S]) ShellEditSystem();
if (key[SCAN_ALT] && key[SCAN_N]) NewMAP();
if (key[SCAN_ALT] && key[SCAN_P]) MPDialog();
if (!key[SCAN_ALT] && key[SCAN_P]) { pasting^=1; key[SCAN_P]=0; } // aen
if (key[SCAN_A] && el<6)
{
lt++;
if (lt==numtiles) lt=0;
key[SCAN_A]=0;
}
if (key[SCAN_Z] && el<6)
{
if (lt) lt--;
else lt=numtiles-1;
key[SCAN_Z]=0;
}
if (key[SCAN_A] && el==7)
{
curzone++;
key[SCAN_A]=0;
}
if (key[SCAN_Z] && el==7)
{
curzone--;
key[SCAN_Z]=0;
}
if (key[SCAN_S])
{
rt++;
if (rt==numtiles) rt=0;
key[SCAN_S]=0;
}
if (key[SCAN_X])
{
if (rt) rt--;
else rt=numtiles-1;
key[SCAN_X]=0;
}
if (key[SCAN_F10])
{
key[SCAN_F10]=0;
if (random(0,255)<15) HAL();
SaveMAP(mapname);
SaveVSP(vspname);
CompileMAP();
Message("MAP/VSP saved.",100);
modified=0;
}
if (key[SCAN_C])
{
key[SCAN_C]=0;
sprintf(strbuf,"Left: %d Right: %d", lt, rt);
Message(strbuf, 300);
}
if (key[SCAN_M])
{
key[SCAN_M]=0;
GenerateMiniVSP();
MiniMAP();
}
if (key[SCAN_H])
{
key[SCAN_H]=0;
mh=mh^1;
if (mh) Message("MAP Tile Highlight enabled.",100);
else Message("MAP Tile Highlight disabled.",100);
}
// ***
// movement code moved to PollMovement()
// ***
if (key[SCAN_PGUP])
{
key[SCAN_PGUP]=0;
ywin -= sy;
if (ywin < 0)
ywin = 0;
}
if (key[SCAN_HOME])
{
key[SCAN_HOME]=0;
xwin -= sx;
if (xwin < 0)
xwin = 0;
}
if (key[SCAN_END])
{
key[SCAN_END]=0;
xwin += sx;
if (xwin > xmax)
xwin = xmax;
}
if (key[SCAN_PGDN])
{
key[SCAN_PGDN]=0;
ywin += sy;
if (ywin > ymax)
ywin = ymax;
}
if (key[SCAN_CTRL] && el<6)
{
key[SCAN_CTRL]=0;
TileSelector();
}
if (key[SCAN_CTRL] && el==7)
{
key[SCAN_CTRL]=0;
ZoneEdDialog();
}
if (key[SCAN_TAB])
{
key[SCAN_TAB]=0;
if (scrollmode)
{
scrollmode=0;
xwin=xwin/16; xwin=xwin*16;
ywin=ywin/16; ywin=ywin*16;
Message("Tile scroll.",150);
}
else
{
scrollmode=1;
Message("Pixel scroll.",150);
}
}
if (key[SCAN_1])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[0]=0;
return;
}
layertoggle[0]=1;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
el=0;
key[SCAN_1]=0;
}
if (key[SCAN_2])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[1]=0;
return;
}
key[SCAN_2]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
if (numlayers>1)
{ layertoggle[1]=1;
el=1; }
}
if (key[SCAN_3])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[2]=0;
return;
}
key[SCAN_3]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
if (numlayers>2)
{ layertoggle[2]=1;
el=2; }
}
if (key[SCAN_4])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[3]=0;
return;
}
key[SCAN_4]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
if (numlayers>3)
{ layertoggle[3]=1;
el=3; }
}
if (key[SCAN_5])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[4]=0;
return;
}
key[SCAN_5]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
if (numlayers>4)
{ layertoggle[4]=1;
el=4; }
}
if (key[SCAN_6])
{
if (key[SCAN_LSHIFT] || key[SCAN_RSHIFT])
{
layertoggle[5]=0;
return;
}
key[SCAN_6]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
if (numlayers>5)
{ layertoggle[5]=1;
el=5; }
}
if (key[SCAN_O])
{
key[SCAN_O]=0;
layertoggle[6]=1; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=0;
el=6;
}
if (key[SCAN_N])
{
key[SCAN_N]=0;
layertoggle[6]=0; layertoggle[7]=1;
layertoggle[8]=0; layertoggle[9]=0;
el=7;
}
if (key[SCAN_E])
{
key[SCAN_E]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=1; layertoggle[9]=0;
el=8;
}
if (key[SCAN_T])
{
key[SCAN_T]=0;
layertoggle[6]=0; layertoggle[7]=0;
layertoggle[8]=0; layertoggle[9]=1;
el=9;
}
if (key[SCAN_F9])
{ // aen
key[SCAN_F9]=0;
mouse_scroll^=1;
sprintf(strbuf,"Mouse scroll %sabled.", mouse_scroll ? "en" : "dis");
Message(strbuf, 100);
}
if (key[SCAN_F11])
{
key[SCAN_F11]=0;
ScreenShot();
Message("Screen capture saved.",300);
}
if (key[SCAN_F12])
{
key[SCAN_F12]=0;
OutputVSPpcx();
Message("PCX file exported.",300);
}
if (key[SCAN_LANGLE])
{
key[SCAN_LANGLE]=0;
ShutdownVideo();
vm=0;
InitVideo(0);
set_intensity(63);
InitMouse();
// aen -- gotta recalc this if you're in a lower res at the bottom of
// the map and jump to a higher res.
xmax = (layer[0].sizex * 16) - sx;
ymax = (layer[0].sizey * 16) - sy;
if (xwin > xmax) xwin=xmax;
if (ywin > ymax) ywin=ymax;
}
if (key[SCAN_RANGLE])
{
key[SCAN_RANGLE]=0;
ShutdownVideo();
vm=1;
InitVideo(1);
set_intensity(63);
InitMouse();
// aen -- gotta recalc this if you're in a lower res at the bottom of
// the map and jump to a higher res.
xmax = (layer[0].sizex * 16) - sx;
ymax = (layer[0].sizey * 16) - sy;
if (xwin > xmax) xwin=xmax;
if (ywin > ymax) ywin=ymax;
}
if (CheckMouseTabs()) return;
if (mb>=3) MainMenu(mx-4,my-5);
if (key[SCAN_ESC]) DoMainMenu();
if (mb==1 && key[SCAN_SLASH] && el<6)
{
lt=layers[el][((((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16) *
layer[el].sizex)+(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)/16)];
return;
}
if (mb==2 && key[SCAN_SLASH] && el<6)
{
rt=layers[el][((((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16) *
layer[el].sizex)+(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)/16)];
return;
}
// aen; these must come before the tile plotting code just below
// to work correctly.
if (mb && el<6 && key[SCAN_LSHIFT] && !shifted)
{
selx1=(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)/16);
sely1=(((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16);
selx2=selx1;
sely2=sely1;
shifted=mb;
return;
}
if (mb && el<6 && shifted)
{
selx2=(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)/16);
sely2=(((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16);
return;
}
if (!mb && el<6 && shifted)
{ int i,j;
int x1,y1,x2,y2;
x1=selx1;
y1=sely1;
x2=selx2;
y2=sely2;
if (x2<x1) x2^=x1,x1^=x2,x2^=x1;
if (y2<y1) y2^=y1,y1^=y2,y2^=y1;
copybuf_wide=x2-x1+1;
copybuf_deep=y2-y1+1;
if (shifted==2)
{
// block fill
modified=1;
for (j=0; j<copybuf_deep; j++)
{
for (i=0; i<copybuf_wide; i++)
layers[el][((y1+j)*layer[el].sizex)+(x1+i)]=lt;
}
}
if (shifted==1)
{
modified=1;
if (copybuf) vfree(copybuf);
copybuf=(word *)valloc(copybuf_wide*copybuf_deep*2, "copybuf", 0);
// copy
for (j=0; j<copybuf_deep; j++)
{
for (i=0; i<copybuf_wide; i++)
copybuf[(j*copybuf_wide)+i]=layers[el][((y1+j)*layer[el].sizex)+(x1+i)];
}
pasting=1;
}
selx1=sely1=0;
selx2=sely2=0;
shifted=0;
}
if (mb==1 && el<6 && !shifted && pasting)
{ int a,b,i,j;
a=(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)/16);
b=(((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16);
// paste
for (j=0; j<copybuf_deep; j++)
{
for (i=0; i<copybuf_wide; i++)
{
if (b+j<layer[el].sizey && a+i<layer[el].sizex)
layers[el][((b+j)*layer[el].sizex)+(a+i)]=copybuf[(j*copybuf_wide)+i];
}
}
}
if (mb==1 && el<6 && !shifted && !pasting)
{
if (mx>335) mx=334;
modified=1;
layers[el][((((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16) *
layer[el].sizex)+(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)
/16)]=lt;
}
if (mb==2 && el<6 && !shifted)
{
if (mx>335) mx=334;
modified=1;
layers[el][((((ywin*layer[el].pmulty/layer[el].pdivy)+my-16)/16) *
layer[el].sizex)+(((xwin*layer[el].pmultx/layer[el].pdivx)+mx-16)
/16)]=rt;
}
if (mb==1 && el==6)
{
modified=1;
obstruct[((((ywin*layer[0].pmulty/layer[0].pdivy)+my-16)/16) *
layer[0].sizex)+(((xwin*layer[0].pmultx/layer[0].pdivx)+mx-16)
/16)]=1;
}
if (mb==2 && el==6)
{
modified=1;
obstruct[((((ywin*layer[0].pmulty/layer[0].pdivy)+my-16)/16) *
layer[0].sizex)+(((xwin*layer[0].pmultx/layer[0].pdivx)+mx-16)
/16)]=0;
}
if (mb==1 && el==7 && (key[SCAN_LSHIFT] || key[SCAN_RSHIFT]))
{
curzone=zone[((((ywin*layer[0].pmulty/layer[0].pdivy)+my-16)/16) *
layer[0].sizex)+(((xwin*layer[0].pmultx/layer[0].pdivx)+mx-16)
/16)];
WaitRelease();
ZoneEdDialog();
return;
}
if (mb==1 && el==7)
{
modified=1;
zone[((((ywin*layer[0].pmulty/layer[0].pdivy)+my-16)/16) *
layer[0].sizex)+(((xwin*layer[0].pmultx/layer[0].pdivx)+mx-16)
/16)]=curzone;
}
if (mb==2 && el==7)
{
modified=1;
zone[((((ywin*layer[0].pmulty/layer[0].pdivy)+my-16)/16) *
layer[0].sizex)+(((xwin*layer[0].pmultx/layer[0].pdivx)+mx-16)
/16)]=0;
}
if (mb==1 && el==8)
{
WaitRelease();
ProcessEntity((xwin+(mx-16))/16,(ywin+(my-16))/16);
modified=1;
}
if (el==8 && EntityThere((mx-16+xwin)/16,(my+ywin-16)/16) &&
key[SCAN_DEL])
{
WaitRelease();
DeleteEntity((mx-16+xwin)/16,(my-16+ywin)/16);
modified=1;
}
}
static struct flist *asymm_and_merge(RefList *in, const SymOpList *sym,
UnitCell *cell, double rmin, double rmax,
SymOpList *amb)
{
Reflection *refl;
RefListIterator *iter;
RefList *asym;
struct flist *f;
int n;
asym = reflist_new();
if ( asym == NULL ) return NULL;
for ( refl = first_refl(in, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
signed int ha, ka, la;
Reflection *cr;
double res;
get_indices(refl, &h, &k, &l);
if ( cell == NULL ) {
ERROR("Can't calculate resolution cutoff - no cell\n");
} else {
res = 2.0*resolution(cell, h, k, l);
if ( res < rmin ) continue;
if ( res > rmax ) continue;
}
get_asymm(sym, h, k, l, &ha, &ka, &la);
if ( amb != NULL ) {
signed int hr, kr, lr;
signed int hra, kra, lra;
get_equiv(amb, NULL, 0, ha, ka, la, &hr, &kr, &lr);
get_asymm(sym, hr, kr, lr, &hra, &kra, &lra);
/* Skip twin-proof reflections */
if ( (ha==hra) && (ka==kra) && (la==lra) ) {
//STATUS("%i %i %i is twin proof\n", h, k, l);
continue;
}
}
cr = find_refl(asym, ha, ka, la);
if ( cr == NULL ) {
cr = add_refl(asym, ha, ka, la);
assert(cr != NULL);
copy_data(cr, refl);
} else {
const double i = get_intensity(cr);
const int r = get_redundancy(cr);
set_intensity(cr, (r*i + get_intensity(refl))/(r+1));
set_redundancy(cr, r+1);
}
}
f = malloc(sizeof(struct flist));
if ( f == NULL ) {
ERROR("Failed to allocate flist\n");
return NULL;
}
n = num_reflections(asym);
f->s = malloc(n*sizeof(unsigned int));
f->s_reidx = malloc(n*sizeof(unsigned int));
f->i = malloc(n*sizeof(float));
f->i_reidx = malloc(n*sizeof(float));
if ( (f->s == NULL) || (f->i == NULL)
|| (f->s_reidx == NULL) || (f->i_reidx == NULL) ) {
ERROR("Failed to allocate flist\n");
return NULL;
}
f->n = 0;
for ( refl = first_refl(asym, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
get_indices(refl, &h, &k, &l);
f->s[f->n] = SERIAL(h, k, l);
f->i[f->n] = get_intensity(refl);
f->n++;
}
assert(f->n == n);
if ( amb != NULL ) {
RefList *reidx = reflist_new();
if ( reidx == NULL ) return NULL;
for ( refl = first_refl(asym, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
signed int hr, kr, lr;
signed int hra, kra, lra;
Reflection *cr;
get_indices(refl, &h, &k, &l);
get_equiv(amb, NULL, 0, h, k, l, &hr, &kr, &lr);
get_asymm(sym, hr, kr, lr, &hra, &kra, &lra);
cr = add_refl(reidx, hra, kra, lra);
copy_data(cr, refl);
}
n = 0;
for ( refl = first_refl(reidx, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
get_indices(refl, &h, &k, &l);
f->s_reidx[n] = SERIAL(h, k, l);
f->i_reidx[n++] = get_intensity(refl);
}
reflist_free(reidx);
}
reflist_free(asym);
return f;
}
esch_error_codes EschFastAttenLight::load(XFParseIFF *iff, const char *lname)
{
assertMyth("EschFastAttenLight::load requries iff pointer",
iff);
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ Floating-point format
if (iff->chunkid == iff->makeid('E','F','A','1'))
{
EschFileLightAtten fatn;
if (iff->chunkSize != sizeof(fatn))
return ESCH_ERR_INVALIDDATA;
//ִִ Read chunk and verify name, if given.
if (iff->read(&fatn))
return ESCH_ERR_FILEERROR;
if (lname && strcmp(lname,fatn.name))
return ESCH_ERR_NOTFOUND;
//ִִ Found, so setup Fast Atten Light
strcpy(name,fatn.name);
flags = fatn.flags;
VngoColor24bit c(fatn.color);
set_intensity( max( max(c.r, c.g), c.b ) );
set_position(fatn.x,fatn.y,fatn.z);
set_inner( fatn.inner );
set_outer( fatn.outer );
}
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ Fixed-point format
else if (iff->chunkid == iff->makeid('E','F','A','T'))
{
EschFileLightAttenV1 fatn;
if (iff->chunkSize != sizeof(fatn))
return ESCH_ERR_INVALIDDATA;
//ִִ Read chunk and verify name, if given.
if (iff->read(&fatn))
return ESCH_ERR_FILEERROR;
if (lname && strcmp(lname,fatn.name))
return ESCH_ERR_NOTFOUND;
//ִִ Found, so setup Fast Atten Light
strcpy(name,fatn.name);
flags = fatn.flags;
VngoColor24bit c(fatn.color);
set_intensity( max( max(c.r, c.g), c.b ) );
set_position(fatn.x / 65536.0f,fatn.y / 65536.0f,fatn.z / 65536.0f);
set_inner( fatn.inner / 65536.0f );
set_outer( fatn.outer / 65536.0f );
}
else
{
return ESCH_ERR_NOTFOUND;
}
//ִִ Return ok
return ESCH_ERR_NONE;
}
DirectionalLight::DirectionalLight(Vector3f direction, Color intensity): direction(direction) {set_intensity(intensity);}
/**
* \brief Set the color.
* \param c The color.
*/
void bear::visual::bitmap_rendering_attributes::set_color(const color_type& c)
{
set_intensity
( c.get_red_intensity(), c.get_green_intensity(), c.get_blue_intensity());
set_opacity( c.get_opacity() );
} // bitmap_rendering_attributes::set_color()
