~hikiko/nux/arb-srgba-shader

RGBAPropertyItem::RGBAPropertyItem(const TCHAR* name, float red /* = 1.0f*/, float green /* = 1.0f*/, float blue /* = 1.0f*/, float alpha /* = 1.0f*/)

: SectionProperty(name, NODE_TYPE_RGBA)

, m_color_model(CM_RGB)

, m_color_format(Color::COLORFORMAT_FLOAT)

{

m_red = new ColorGradientPropertyItem(TEXT("Red"));

m_green = new ColorGradientPropertyItem(TEXT("Green"));

m_blue = new ColorGradientPropertyItem(TEXT("Blue"));

m_alpha = new ColorGradientPropertyItem(TEXT("Alpha"));

m_ColorModel = smptr(Button)(new Button(TEXT("RGB")));

m_ColorModel->SetMinMaxSize(32, 14);

m_ColorModel->SetFont(GFontBold);

m_ColorFormat = smptr(Button)(new Button(TEXT("float")));

m_ColorFormat->SetMinMaxSize(32, 14);

m_ColorFormat->SetFont(GFontBold);

PushChildBack(m_red);

PushChildBack(m_green);

PushChildBack(m_blue);

PushChildBack(m_alpha);

float r = Clamp(red, 0.0f, 1.0f);

float g = Clamp(green, 0.0f, 1.0f);

float b = Clamp(blue, 0.0f, 1.0f);

float a = Clamp(alpha, 0.0f, 1.0f);

m_red->SetColorFormat(m_color_format);

m_green->SetColorFormat(m_color_format);

m_blue->SetColorFormat(m_color_format);

m_alpha->SetColorFormat(m_color_format);

m_red->SetRange(0.0f, 1.0f);

m_red->SetValue(r);

m_green->SetRange(0.0f, 1.0f);

m_green->SetValue(g);

m_blue->SetRange(0.0f, 1.0f);

m_blue->SetValue(b);

m_alpha->SetRange(0.0f, 1.0f);

m_alpha->SetValue(a);

m_red->AddColorMark(0, Color(0.0f, g, b), false);

m_red->AddColorMark(1, Color(1.0f, g, b), false);

m_green->AddColorMark(0, Color(r, 0.0f, b), false);

m_green->AddColorMark(1, Color(r, 1.0f, b), false);

m_blue->AddColorMark(0, Color(r, g, 0.0f), false);

m_blue->AddColorMark(1, Color(r, g, 1.0f), false);

m_alpha->AddColorMark(0, Color(0xFF000000), false);

m_alpha->AddColorMark(1, Color(0xFFFFFFFF), false);

UpdateStartToEndColors();

m_red->sigValueChanged.connect( sigc::mem_fun(this, &RGBAPropertyItem::RedChange));

m_green->sigValueChanged.connect( sigc::mem_fun(this, &RGBAPropertyItem::GreenChange));

m_blue->sigValueChanged.connect( sigc::mem_fun(this, &RGBAPropertyItem::BlueChange));

m_alpha->sigValueChanged.connect( sigc::mem_fun(this, &RGBAPropertyItem::AlphaChange));

m_ColorModel->sigClick.connect(sigc::mem_fun(this, &RGBAPropertyItem::OnChangeColorModel));

m_ColorFormat->sigClick.connect(sigc::mem_fun(this, &RGBAPropertyItem::OnChangeColorFormat));

NODE_SIG_CONNECT(m_red->sigValueChanged, RGBAPropertyItem, RecvPropertyChange);

NODE_SIG_CONNECT(m_green->sigValueChanged, RGBAPropertyItem, RecvPropertyChange);

NODE_SIG_CONNECT(m_blue->sigValueChanged, RGBAPropertyItem, RecvPropertyChange);

NODE_SIG_CONNECT(m_alpha->sigValueChanged, RGBAPropertyItem, RecvPropertyChange);

}

RGBAPropertyItem::~RGBAPropertyItem()

{

INL_SAFE_DELETE(m_red);

100

INL_SAFE_DELETE(m_green);

101

INL_SAFE_DELETE(m_blue);

102

INL_SAFE_DELETE(m_alpha);

103

}

104

105

long RGBAPropertyItem::ProcessPropertyEvent(IEvent &ievent, long TraverseInfo, long ProcessEventInfo)

106

{

107

long ret = TraverseInfo;

108

109

ret = m_ColorModel->ProcessEvent(ievent, ret, ProcessEventInfo);

110

ret = m_ColorFormat->ProcessEvent(ievent, ret, ProcessEventInfo);

111

// if(!(ret & eMouseEventSolved))

112

// ret = TableItem::ProcessPropertyEvent(ievent, TraverseInfo, ProcessEventInfo);

113

return ret;

114

}

115

116

void RGBAPropertyItem::ComputePropertyLayout(int x, int y, RowHeader* row, const std::vector<header2>& column_vector)

117

{

118

if(m_ItemGeometryVector.size() >= 2)

119

{

120

Geometry geo;

121

geo = m_ItemGeometryVector[1];

122

geo = geo.GetExpand(-PROPERTY_BORDER_X, -PROPERTY_BORDER_Y);

123

124

m_ColorModel->SetBaseX(geo.x + geo.GetWidth() - PROPERTY_BORDER_X - m_ColorModel->GetBaseWidth() - 2 - m_ColorModel->GetBaseWidth());

125

m_ColorModel->SetBaseY(geo.y);

126

127

m_ColorFormat->SetBaseX(geo.x + geo.GetWidth() - PROPERTY_BORDER_X - m_ColorModel->GetBaseWidth());

128

m_ColorFormat->SetBaseY(geo.y);

129

}

130

131

}

132

133

int RGBAPropertyItem::GetItemBestHeight()

134

{

135

int sz = 16; //m_ColorModel->GetBaseHeight();

136

return sz + 2 * PROPERTY_BORDER_Y;

137

}

138

139

void RGBAPropertyItem::RedChange(const weaksmptr(ColorGradient) slider)

140

{

141

if(slider->IsCtrlKeyPressed())

142

{

143

m_green->SetValue(slider->GetValue());

144

m_blue->SetValue(slider->GetValue());

145

}

146

UpdateStartToEndColors();

147

m_green->NeedRedraw();

148

m_blue->NeedRedraw();

149

m_alpha->NeedRedraw();

150

}

151

152

void RGBAPropertyItem::GreenChange(const weaksmptr(ColorGradient) slider)

153

{

154

if(slider->IsCtrlKeyPressed())

155

{

156

m_red->SetValue(slider->GetValue());

157

m_blue->SetValue(slider->GetValue());

158

}

159

UpdateStartToEndColors();

160

m_red->NeedRedraw();

161

m_blue->NeedRedraw();

162

m_alpha->NeedRedraw();

163

}

164

165

void RGBAPropertyItem::BlueChange(const weaksmptr(ColorGradient) slider)

166

{

167

if(slider->IsCtrlKeyPressed())

168

{

169

m_red->SetValue(slider->GetValue());

170

m_green->SetValue(slider->GetValue());

171

}

172

UpdateStartToEndColors();

173

m_red->NeedRedraw();

174

m_green->NeedRedraw();

175

m_alpha->NeedRedraw();

176

}

177

178

void RGBAPropertyItem::AlphaChange(const weaksmptr(ColorGradient) slider)

179

{

180

UpdateStartToEndColors();

181

182

m_red->NeedRedraw();

183

m_green->NeedRedraw();

184

m_blue->NeedRedraw();

185

m_alpha->NeedRedraw();

186

}

187

188

void RGBAPropertyItem::DrawProperty(GraphicsContext& GfxContext, TableCtrl* table, bool force_draw, Geometry geo, const BasePainter& Painter,

189

RowHeader* row, const std::vector<header2>& column_vector, Color ItemBackgroundColor)

190

{

191

bool isSelected = (this == table->GetSelectedItem());

192

if(isDirtyItem() ||

193

m_red->IsRedrawNeeded() ||

194

m_green->IsRedrawNeeded() ||

195

m_blue->IsRedrawNeeded() ||

196

m_alpha->IsRedrawNeeded())

197

{

198

UINT nBackground = table->PushItemBackground(GfxContext, this);

199

Painter.PaintTextLineStatic(GfxContext, GFontBold /*GetFont()*/, m_FirstColumnUsableGeometry, row->item->GetName(), GetItemTextColor());

200

201

if(m_ItemGeometryVector.size() >= 2)

202

{

203

Geometry prop_geo = m_ItemGeometryVector[1];

204

prop_geo = prop_geo.GetExpand(-PROPERTY_BORDER_X,

205

-2*PROPERTY_BORDER_Y);

206

prop_geo.OffsetSize( - 2 - m_ColorFormat->GetBaseWidth() - 2 - m_ColorModel->GetBaseWidth() - 2, 0);

207

208

// Draw the resulting color

209

Painter.Paint2DQuadColor(GfxContext, prop_geo, Color(m_Red, m_Green, m_Blue));

210

// Draw black border around the color

211

Painter.Paint2DQuadWireframe(GfxContext, prop_geo, Color(0));

212

m_ColorModel->ProcessDraw(GfxContext, true);

213

m_ColorFormat->ProcessDraw(GfxContext, true);

214

}

215

table->PopItemBackground(GfxContext, nBackground);

216

}

217

}

218

219

void RGBAPropertyItem::OnChangeColorModel()

220

{

221

if(m_color_model == CM_RGB)

222

{

223

SetColorModel(CM_HLS);

224

float H, L, S;

225

RGBtoHLS(m_red->GetValue(), m_green->GetValue(), m_blue->GetValue(), H, L, S);

226

m_red->SetValue(H); m_green->SetValue(L); m_blue->SetValue(S);

227

}

228

else if(m_color_model == CM_HLS)

229

{

230

SetColorModel(CM_HSV);

231

float H, S, V;

232

float R, G, B;

233

HLStoRGB(R, G, B, m_red->GetValue(), m_green->GetValue(), m_blue->GetValue());

234

RGBtoHSV(R, G, B, H, S, V);

235

m_red->SetValue(H); m_green->SetValue(S); m_blue->SetValue(V);

236

237

if(H == -1.0f)

238

{

239

H = 0;

240

}

241

}

242

else if(m_color_model == CM_HSV)

243

{

244

SetColorModel(CM_RGB);

245

float R, G, B;

246

HSVtoRGB(R, G, B, m_red->GetValue(), m_green->GetValue(), m_blue->GetValue());

247

m_red->SetValue(R); m_green->SetValue(G); m_blue->SetValue(B);

248

249

}

250

251

UpdateStartToEndColors();

252

m_green->NeedRedraw();

253

m_blue->NeedRedraw();

254

m_alpha->NeedRedraw();

255

}

256

257

void RGBAPropertyItem::SetColorModel(eColorModel cm)

258

{

259

if(cm == CM_RGB)

260

{

261

m_color_model = CM_RGB;

262

m_ColorModel->SetCaption(TEXT("RGB"));

263

264

m_red->SetName(TEXT("Red"));

265

m_green->SetName(TEXT("Green"));

266

m_blue->SetName(TEXT("Blue"));

267

m_alpha->SetName(TEXT("Alpha"));

268

}

269

if(cm == CM_HSV)

270

{

271

m_color_model = CM_HSV;

272

m_ColorModel->SetCaption(TEXT("HSV"));

273

274

m_red->SetName(TEXT("Hue"));

275

m_green->SetName(TEXT("Saturation"));

276

m_blue->SetName(TEXT("Value"));

277

m_alpha->SetName(TEXT("Alpha"));

278

}

279

if(cm == CM_HLS)

280

{

281

m_color_model = CM_HLS;

282

m_ColorModel->SetCaption(TEXT("HLS"));

283

284

m_red->SetName(TEXT("Hue"));

285

m_green->SetName(TEXT("Light"));

286

m_blue->SetName(TEXT("Saturation"));

287

m_alpha->SetName(TEXT("Alpha"));

288

}

289

if(cm == CM_YUV)

290

{

291

m_color_model = CM_YUV;

292

m_ColorModel->SetBaseString(TEXT("YUV"));

293

294

// m_ComponentLabel0->SetBaseString(TEXT("Y"));

295

// m_ComponentLabel1->SetBaseString(TEXT("U"));

296

// m_ComponentLabel2->SetBaseString(TEXT("V"));

297

// m_ComponentAlpha->SetBaseString(TEXT("A"));

298

}

299

}

300

301

302

void RGBAPropertyItem::OnChangeColorFormat()

303

{

304

if(m_color_format == Color::COLORFORMAT_FLOAT)

305

{

306

m_color_format = Color::COLORFORMAT_INT;

307

m_ColorFormat->SetCaption(TEXT("int"));

308

}

309

else if(m_color_format == Color::COLORFORMAT_INT)

310

{

311

m_color_format = Color::COLORFORMAT_HEX;

312

m_ColorFormat->SetCaption(TEXT("hex"));

313

}

314

else if(m_color_format == Color::COLORFORMAT_HEX)

315

{

316

m_color_format = Color::COLORFORMAT_FLOAT;

317

m_ColorFormat->SetCaption(TEXT("float"));

318

}

319

320

m_red->SetColorFormat(m_color_format);

321

m_green->SetColorFormat(m_color_format);

322

m_blue->SetColorFormat(m_color_format);

323

m_alpha->SetColorFormat(m_color_format);

324

}

325

326

void RGBAPropertyItem::UpdateStartToEndColors()

327

{

328

m_red->Reset();

329

m_green->Reset();

330

m_blue->Reset();

331

m_alpha->Reset();

332

333

if(m_color_model == CM_RGB)

334

{

335

float r, g, b, a;

336

r = m_red->GetValue();

337

g = m_green->GetValue();

338

b = m_blue->GetValue();

339

a = m_alpha->GetValue();

340

341

m_red->AddColorMark(0, Color(0.0f, g, b), false);

342

m_red->AddColorMark(1, Color(1.0f, g, b), false);

343

m_green->AddColorMark(0, Color(r, 0.0f, b), false);

344

m_green->AddColorMark(1, Color(r, 1.0f, b), false);

345

m_blue->AddColorMark(0, Color(r, g, 0.0f), false);

346

m_blue->AddColorMark(1, Color(r, g, 1.0f), false);

347

m_alpha->AddColorMark(0, Color(0xFF000000), false);

348

m_alpha->AddColorMark(1, Color(0xFFFFFFFF), false);

349

350

m_Red = r;

351

m_Green = g;

352

m_Blue = b;

353

m_Alpha = a;

354

}

355

356

if(m_color_model == CM_HSV)

357

{

358

float r, g, b, a;

359

float h, s, v;

360

h = m_red->GetValue();

361

s = m_green->GetValue();

362

v = m_blue->GetValue();

363

a = m_alpha->GetValue();

364

365

HSVtoRGB(r, g, b, h, 1.0f, 1.0f);

366

367

m_red->AddColorMark(0.0f, Color(1.0f, 0.0, 0.0), false);

368

m_red->AddColorMark(1.0f/6.0f, Color(1.0f, 1.0, 0.0), false);

369

m_red->AddColorMark(2.0f/6.0f, Color(0.0f, 1.0, 0.0), false);

370

m_red->AddColorMark(3.0f/6.0f, Color(0.0f, 1.0, 1.0), false);

371

m_red->AddColorMark(4.0f/6.0f, Color(0.0f, 0.0, 1.0), false);

372

m_red->AddColorMark(5.0f/6.0f, Color(1.0f, 0.0, 1.0), false);

373

m_red->AddColorMark(1.0f, Color(1.0f, 0.0, 0.0), false);

374

375

if(h == 1.0f)

376

h = 0.0f;

377

HSVtoRGB(r, g, b, h, 1.0f, 1.0f);

378

m_green->AddColorMark(0, Color(v, v, v), false);

379

m_green->AddColorMark(1.0f, Color(r * v, g * v, b * v), false);

380

381

HSVtoRGB(r, g, b, h, s, 1.0f);

382

m_blue->AddColorMark(0, Color(0, 0, 0), false);

383

m_blue->AddColorMark(1.0f, Color(r, g, b), false);

384

385

m_alpha->AddColorMark(0, Color(0xFF000000), false);

386

m_alpha->AddColorMark(1, Color(0xFFFFFFFF), false);

387

388

HSVtoRGB(m_Red, m_Green, m_Blue, h, s, v);

389

m_Alpha = a;

390

}

391

392

if(m_color_model == CM_HLS)

393

{

394

float r, g, b, a;

395

float h, l, s;

396

h = m_red->GetValue();

397

l = m_green->GetValue();

398

s = m_blue->GetValue();

399

a = m_alpha->GetValue();

400

401

m_red->AddColorMark(0.0f, Color(1.0f, 0.0, 0.0), false);

402

m_red->AddColorMark(1.0f/6.0f, Color(1.0f, 1.0, 0.0), false);

403

m_red->AddColorMark(2.0f/6.0f, Color(0.0f, 1.0, 0.0), false);

404

m_red->AddColorMark(3.0f/6.0f, Color(0.0f, 1.0, 1.0), false);

405

m_red->AddColorMark(4.0f/6.0f, Color(0.0f, 0.0, 1.0), false);

406

m_red->AddColorMark(5.0f/6.0f, Color(1.0f, 0.0, 1.0), false);

407

m_red->AddColorMark(1.0f, Color(1.0f, 0.0, 0.0), false);

408

409

s = 1.0f - s;

410

if(h == 1.0f)

411

h = 0.0f;

412

413

// Need to use HSVtoRGB to compute the primary color

414

HSVtoRGB(r, g, b, h, 1.0f, 1.0f);

415

m_green->AddColorMark(0.0f, Color(0, 0, 0), false);

416

m_green->AddColorMark(0.5f, Color(r*(1-s)+0.5f*s, g*(1-s)+0.5f*s, b*(1-s)+0.5f*s), false);

417

m_green->AddColorMark(1.0f, Color(1.0f, 1.0f, 1.0f), false);

418

419

float cr, cg, cb;

420

if(l > 0.5)

421

{

422

float factor = (l-0.5f)/0.5f;

423

cr = (1 - factor) * r*(1-s)+0.5*s + factor * 1.0f;

424

cg = (1 - factor) * g*(1-s)+0.5*s + factor * 1.0f;

425

cb = (1 - factor) * b*(1-s)+0.5*s + factor * 1.0f;

426

}

427

else

428

{

429

float factor = l/0.5f;

430

cr = (factor) * r*(1-s)+0.5*s;

431

cg = (factor) * g*(1-s)+0.5*s;

432

cb = (factor) * b*(1-s)+0.5*s;

433

}

434

435

m_blue->AddColorMark(0, Color(l, l, l), false);

436

m_blue->AddColorMark(1.0f, Color(cr, cg, cb), false);

437

438

439

m_alpha->AddColorMark(0, Color(0xFF000000), false);

440

m_alpha->AddColorMark(1, Color(0xFFFFFFFF), false);

441

442

HLStoRGB(m_Red, m_Green, m_Blue, h, l, 1.0f - s);

443

m_Alpha = a;

444

}

445

}

446

447

RGBAPropertyItem* RGBAPropertyItem::CreateFromXML(const TiXmlElement* elementxml, NodeNetCom* parent, const char* Name, int id)

448

{

449

RGBAPropertyItem *node = new RGBAPropertyItem(Name, 0, 0, 0, 0);

450

double red, green, blue, alpha;

451

452

const TiXmlElement* childxml = elementxml->FirstChildElement();

453

QueryNodeXMLDoubleAttribute(childxml, TEXT("Red"), &red, -1);

454

childxml = childxml->NextSiblingElement();

455

QueryNodeXMLDoubleAttribute(childxml, TEXT("Green"), &green, -1);

456

childxml = childxml->NextSiblingElement();

457

QueryNodeXMLDoubleAttribute(childxml, TEXT("Blue"), &blue, -1);

458

childxml = childxml->NextSiblingElement();

459

QueryNodeXMLDoubleAttribute(childxml, TEXT("Alpha"), &alpha, -1);

460

461

node->SetRed(red);

462

node->SetGreen(green);

463

node->SetBlue(blue);

464

node->SetAlpha(alpha);

465

466

node->SetID(id);

467

return node;

468

}

469

470

TiXmlElement* RGBAPropertyItem::ToXML() const

471

{

472

TiXmlElement* elementxml = NodeNetCom::ToXML();

473

TiXmlElement* childxml;

474

childxml = new TiXmlElement(TEXT("RGBAComponent"));

475

//childxml->SetAttribute(TEXT("Name"), m_X->GetName());

476

childxml->SetDoubleAttribute(TEXT("Red"), m_Red);

477

elementxml->LinkEndChild(childxml);

478

childxml = new TiXmlElement(TEXT("RGBAComponent"));

479

//childxml->SetAttribute(TEXT("Name"), m_Y->GetName());

480

childxml->SetDoubleAttribute(TEXT("Green"), m_Green);

481

elementxml->LinkEndChild(childxml);

482

childxml = new TiXmlElement(TEXT("RGBAComponent"));

483

//childxml->SetAttribute(TEXT("Name"), m_Z->GetName());

484

childxml->SetDoubleAttribute(TEXT("Blue"), m_Blue);

485

elementxml->LinkEndChild(childxml);

486

childxml = new TiXmlElement(TEXT("RGBAComponent"));

487

//childxml->SetAttribute(TEXT("Name"), m_W->GetName());

488

childxml->SetDoubleAttribute(TEXT("Alpha"), m_Alpha);

489

elementxml->LinkEndChild(childxml);

490

491

return elementxml;

492

}

493

494

bool RGBAPropertyItem::FromXML(const TiXmlElement* elementxml)

495

{

496

double red, green, blue, alpha;

497

tstring NameX, NameY, NameZ, NameW;

498

const TiXmlElement* childxml = elementxml->FirstChildElement();

499

//QueryNodeXMLStringAttribute(childxml, TEXT("Name"), NameX, GetID());

500

QueryNodeXMLDoubleAttribute(childxml, TEXT("Red"), &red, -1);

501

childxml = childxml->NextSiblingElement();

502

//QueryNodeXMLStringAttribute(childxml, TEXT("Name"), NameY, GetID());

503

QueryNodeXMLDoubleAttribute(childxml, TEXT("Green"), &green, -1);

504

childxml = childxml->NextSiblingElement();

505

//QueryNodeXMLStringAttribute(childxml, TEXT("Name"), NameZ, GetID());

506

QueryNodeXMLDoubleAttribute(childxml, TEXT("Blue"), &blue, -1);

507

childxml = childxml->NextSiblingElement();

508

//QueryNodeXMLStringAttribute(childxml, TEXT("Name"), NameW, GetID());

509

QueryNodeXMLDoubleAttribute(childxml, TEXT("Alpha"), &alpha, -1);

510

childxml = childxml->NextSiblingElement();

511

512

SetRed(red);

513

SetGreen(green);

514

SetBlue(blue);

515

SetAlpha(alpha);

516

517

return NodeNetCom::FromXML(elementxml);

518

}

519

520

NAMESPACE_END_GUI