~baltix/+junk/irrlicht-test

virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData) { video::IVideoDriver* driver = services->getVideoDriver(); // set inverted world matrix // if we are using highlevel shaders (the user can select this when // starting the program), we must set the constants by name. core::matrix4 invWorld = driver->getTransform(video::ETS_WORLD); invWorld.makeInverse(); if (UseHighLevelShaders) services->setVertexShaderConstant("mInvWorld", &invWorld.M[0], 16); else services->setVertexShaderConstant(&invWorld.M[0], 0, 4); // set clip matrix core::matrix4 worldViewProj; worldViewProj = driver->getTransform(video::ETS_PROJECTION); worldViewProj *= driver->getTransform(video::ETS_VIEW); worldViewProj *= driver->getTransform(video::ETS_WORLD); if (UseHighLevelShaders) services->setVertexShaderConstant("mWorldViewProj", &worldViewProj.M[0], 16); else services->setVertexShaderConstant(&worldViewProj.M[0], 4, 4); // set camera position core::vector3df pos = device->getSceneManager()-> getActiveCamera()->getAbsolutePosition(); if (UseHighLevelShaders) services->setVertexShaderConstant("mLightPos", reinterpret_cast<f32*>(&pos), 3); else services->setVertexShaderConstant(reinterpret_cast<f32*>(&pos), 8, 1); // set light color video::SColorf col(0.0f,1.0f,1.0f,0.0f); if (UseHighLevelShaders) services->setVertexShaderConstant("mLightColor", reinterpret_cast<f32*>(&col), 4); else services->setVertexShaderConstant(reinterpret_cast<f32*>(&col), 9, 1); // set transposed world matrix core::matrix4 world = driver->getTransform(video::ETS_WORLD); world = world.getTransposed(); if (UseHighLevelShaders) services->setVertexShaderConstant("mTransWorld", &world.M[0], 16); else services->setVertexShaderConstant(&world.M[0], 10, 4); } };</pre></td>

</tr>

</table>

The next few lines start up the engine. Just like in most other

tutorials before. But in addition, we ask the user if he wants this

example to use high level shaders if he selected a driver which is

capable of doing so.

<tr>

<td> <pre>int main() { // let user select driver type video::E_DRIVER_TYPE driverType = video::EDT_DIRECTX9; printf("Please select the driver you want for this example:\n"\ " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\ " (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\ " (f) NullDevice\n (otherKey) exit\n\n"); char i; std::cin >> i; switch(i) { case 'a': driverType = video::EDT_DIRECT3D9;break; case 'b': driverType = video::EDT_DIRECT3D8;break; case 'c': driverType = video::EDT_OPENGL; break; case 'd': driverType = video::EDT_SOFTWARE; break; case 'e': driverType = video::EDT_BURNINGSVIDEO;break; case 'f': driverType = video::EDT_NULL; break; default: return 1; } // ask the user if we should use high level shaders for this example if (driverType == video::EDT_DIRECT3D9 || driverType == video::EDT_OPENGL)

{ printf("Please press 'y' if you want to use high level shaders.\n"); std::cin >> i; if (i == 'y') UseHighLevelShaders = true; } // create device device = createDevice(driverType, core::dimension2d<s32>(640, 480)); if (device == 0) { printf("\nWas not able to create driver.\n"\ "Please restart and select another driver.\n"); getch(); return 1; } video::IVideoDriver* driver = device->getVideoDriver(); scene::ISceneManager* smgr = device->getSceneManager(); gui::IGUIEnvironment* gui = device->getGUIEnvironment();</pre></td>

</tr>

</table>

Now for the more interesting parts. If we are using Direct3D, we

want to load vertex and pixel shader programs, if we have

OpenGL, we want to use ARB fragment and vertex programs. I wrote the

corresponding programs down into the files d3d8.ps, d3d8.vs, d3d9.ps,

d3d9.vs, opengl.ps and opengl.vs. We only need the right filenames

now. This is done in the following switch. Note, that it is not necessary

to write the shaders into text files, like in this example. You can

even write the shaders directly as strings into the cpp source file,

and use later addShaderMaterial() instead of addShaderMaterialFromFiles().

<tr>

<td> <pre> c8* vsFileName = 0; // filename for the vertex shader c8* psFileName = 0; // filename for the pixel shader switch(driverType) { case video::EDT_DIRECT3D8: psFileName = "../../media/d3d8.psh"; vsFileName = "../../media/d3d8.vsh"; break; case video::EDT_DIRECT3D9: if (UseHighLevelShaders) { psFileName = "../../media/d3d9.hlsl"; vsFileName = psFileName; // both shaders are in the same file } else { psFileName = "../../media/d3d9.psh"; vsFileName = "../../media/d3d9.vsh"; } break; case video::EDT_OPENGL: if (UseHighLevelShaders) { psFileName = "../../media/opengl.frag"; vsFileName = "../../media/opengl.vert"; } else { psFileName = "../../media/opengl.psh"; vsFileName = "../../media/opengl.vsh"; } break; } </pre>

</td>

</tr>

</table>

In addition, we check if the hardware and the selected renderer

is capable of executing the shaders we want. If not, we simply set

100

the filename string to 0. This is not necessary, but useful in this

101

example: For example, if the hardware is able to execute vertex shaders

102

but not pixel shaders, we create a new material which only uses the

103

vertex shader, and no pixel shader. Otherwise, if we would tell the

104

engine to create this material and the engine sees that the hardware

105

wouldn't be able to fullfill the request completely,

106

it would not create any new material at all. So in this example you

107

would see at least the vertex shader in action, without the pixel

108

shader.

109

</div>

110

111

<tr>

112

<td> <pre> if (!driver->queryFeature(video::EVDF_PIXEL_SHADER_1_1) && !driver->queryFeature(video::EVDF_ARB_FRAGMENT_PROGRAM_1)) { device->getLogger()->log("WARNING: Pixel shaders disabled "\ "because of missing driver/hardware support."); psFileName = 0; } if (!driver->queryFeature(video::EVDF_VERTEX_SHADER_1_1) && !driver->queryFeature(video::EVDF_ARB_VERTEX_PROGRAM_1)) { device->getLogger()->log("WARNING: Vertex shaders disabled "\ "because of missing driver/hardware support."); vsFileName = 0; }</pre></td>

113

</tr>

114

</table>

115

Now lets create the new materials.

116

As you maybe know from previous examples, a material type in the Irrlicht

117

engine is set by simply changing the MaterialType value in the SMaterial

118

struct. And this value is just a simple 32 bit value, like video::EMT_SOLID.

119

So we only need the engine to create a new value for us which we can

120

set there. To do this, we get a pointer to the IGPUProgrammingServices

121

and call addShaderMaterialFromFiles(), which returns such a new 32 bit

122

value. That's all.

123

The parameters to this method are the following: First, the names of

124

the files containing the code of the vertex and the pixel shader.

125

If you would use addShaderMaterial() instead, you would not need file

126

names, then you could write the code of the shader directly as string.

127

The following parameter is a pointer to the IShaderConstantSetCallBack

128

class we wrote at the beginning of this tutorial. If you don't want

129

to set constants, set this to 0. The last paramter tells the engine

130

which material it should use as base material.

131

To demonstrate this, we create two materials with a different base material,

132

one with EMT_SOLID and one with EMT_TRANSPARENT_ADD_COLOR.

133

134

<tr>

135

<td><pre> // create materials video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices(); s32 newMaterialType1 = 0; s32 newMaterialType2 = 0; if (gpu) { MyShaderCallBack* mc = new MyShaderCallBack();

136

// create the shaders depending on if the user wanted high level // or low level shaders: if (UseHighLevelShaders) { // create material from high level shaders (hlsl or glsl) newMaterialType1 = gpu->addHighLevelShaderMaterialFromFiles( vsFileName, "vertexMain", video::EVST_VS_1_1, psFileName, "pixelMain", video::EPST_PS_1_1, mc, video::EMT_SOLID); newMaterialType2 = gpu->addHighLevelShaderMaterialFromFiles( vsFileName, "vertexMain", video::EVST_VS_1_1, psFileName, "pixelMain", video::EPST_PS_1_1, mc, video::EMT_TRANSPARENT_ADD_COLOR); } else { // create material from low level shaders (asm or arb_asm) newMaterialType1 = gpu->addShaderMaterialFromFiles(vsFileName, psFileName, mc, video::EMT_SOLID); newMaterialType2 = gpu->addShaderMaterialFromFiles(vsFileName, psFileName, mc, video::EMT_TRANSPARENT_ADD_COLOR); } mc->drop(); } </pre></td>

137

</tr>

138

</table>

139

Now its time for testing out the materials. We create a test cube

140

and set the material we created. In addition, we add a text scene node

141

to the cube and a rotatation animator, to make it look more interesting

142

and important.

143

144

<tr>

145

146

// create test scene node 1, with the new created material type 1

147

148

scene::ISceneNode* node = smgr->addCubeSceneNode(50);

149

node->setPosition(core::vector3df(0,0,0));

150

node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

151

node->setMaterialFlag(video::EMF_LIGHTING, false);

152

node->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType1);

153

154

smgr->addTextSceneNode(gui->getBuiltInFont(),

155

L"PS & VS & EMT_SOLID",

156

video::SColor(255,255,255,255), node);

157

158

scene::ISceneNodeAnimator* anim = smgr->createRotationAnimator(

159

core::vector3df(0,0.3f,0));

160

node->addAnimator(anim);

161

anim->drop();</pre></td>

162

</tr>

163

</table>

164

Same for the second cube, but with the second material we created.

165

166

<tr>

167

<td><pre> // create test scene node 2, with the new created material type 2

168

169

node = smgr->addCubeSceneNode(50);

170

node->setPosition(core::vector3df(0,-10,50));

171

node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

172

node->setMaterialFlag(video::EMF_LIGHTING, false);

173

node->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType2);

174

175

smgr->addTextSceneNode(gui->getBuiltInFont(),

176

L"PS & VS & EMT_TRANSPARENT",

177

video::SColor(255,255,255,255), node);

178

179

anim = smgr->createRotationAnimator(core::vector3df(0,0.3f,0));

180

node->addAnimator(anim);

181

anim->drop();</pre></td>

182

</tr>

183

</table>

184

185

Then we add a third cube without a shader on it, to be able to compare

186

the cubes.

187

188

189

<tr>

190

<td><pre> // add a scene node with no shader

191

192

node = smgr->addCubeSceneNode(50);

193

node->setPosition(core::vector3df(0,50,25));

194

node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

195

node->setMaterialFlag(video::EMF_LIGHTING, false);

196

smgr->addTextSceneNode(gui->getBuiltInFont(), L"NO SHADER",

197

video::SColor(255,255,255,255), node);

198

</pre></td>

199

</tr>

200

</table>

201

202

And last, we add a skybox and a user controlled camera to the scene. For

203

the skybox textures, we disable mipmap generation, because we don't need

204

mipmaps on it.

205

206

207

<tr>

208

<td><pre> // add a nice skybox driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false); smgr->addSkyBoxSceneNode( driver->getTexture("../../media/irrlicht2_up.jpg"), driver->getTexture("../../media/irrlicht2_dn.jpg"), driver->getTexture("../../media/irrlicht2_lf.jpg"), driver->getTexture("../../media/irrlicht2_rt.jpg"), driver->getTexture("../../media/irrlicht2_ft.jpg"), driver->getTexture("../../media/irrlicht2_bk.jpg")); driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true); // add a camera and disable the mouse cursor scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(0, 100.0f, 100.0f); cam->setPosition(core::vector3df(-100,50,100)); cam->setTarget(core::vector3df(0,0,0)); device->getCursorControl()->setVisible(false);</pre></td>

209

</tr>

210

</table>

211

212

Now draw everything. That's all.

213

214

215

<tr>

216

<td><pre> int lastFPS = -1; while(device->run()) if (device->isWindowActive()) { driver->beginScene(true, true, video::SColor(255,0,0,0)); smgr->drawAll(); driver->endScene(); int fps = driver->getFPS(); if (lastFPS != fps) { core::stringw str = L"Irrlicht Engine - Vertex and pixel shader example ["; str += driver->getName(); str += "] FPS:"; str += fps; device->setWindowCaption(str.c_str()); lastFPS = fps; } } device->drop(); return 0; </pre></td>

217

</tr>

218

</table>

219

220

Compile and run this, and I hope you have fun with your new little shader

221

writing tool :).

222

</div>

223

</td>

224

</tr>

225

</table>

226

227

228

<tr>

229

<td bgcolor="#666699"> Shader files</td>

230

</tr>

231

<tr>

232

233

234

The files containing the shaders can be found in the media directory

235

of the SDK. However, they look like this:

236

237

<tr>

238

239

</tr>

240

<tr>

241

<td>

242

<pre>

243

// part of the Irrlicht Engine Shader example.

244

// These simple Direct3D9 pixel and vertex shaders will be loaded by the shaders

245

// example. Please note that these example shaders don't do anything really useful.

246

// They only demonstrate that shaders can be used in Irrlicht.

247

248

//-----------------------------------------------------------------------------

249

// Global variables

250

//-----------------------------------------------------------------------------

251

float4x4 mWorldViewProj; // World * View * Projection transformation

252

float4x4 mInvWorld; // Inverted world matrix

253

float4x4 mTransWorld; // Transposed world matrix

254

float3 mLightPos; // Light position

255

float4 mLightColor; // Light color

256

257

258

// Vertex shader output structure

259

struct VS_OUTPUT

260

{

261

float4 Position : POSITION; // vertex position

262

float4 Diffuse : COLOR0; // vertex diffuse color

263

float2 TexCoord : TEXCOORD0; // tex coords

264

};

265

266

267

VS_OUTPUT vertexMain( in float4 vPosition : POSITION,

268

in float3 vNormal : NORMAL,

269

float2 texCoord : TEXCOORD0 )

270

{

271

VS_OUTPUT Output;

272

273

// transform position to clip space

274

Output.Position = mul(vPosition, mWorldViewProj);

275

276

// transform normal

277

float3 normal = mul(vNormal, mInvWorld);

278

279

// renormalize normal

280

normal = normalize(normal);

281

282

// position in world coodinates

283

float3 worldpos = mul(mTransWorld, vPosition);

284

285

// calculate light vector, vtxpos - lightpos

286

float3 lightVector = worldpos - mLightPos;

287

288

// normalize light vector

289

lightVector = normalize(lightVector);

290

291

// calculate light color

292

float3 tmp = dot(-lightVector, normal);

293

tmp = lit(tmp.x, tmp.y, 1.0);

294

295

tmp = mLightColor * tmp.y;

296

Output.Diffuse = float4(tmp.x, tmp.y, tmp.z, 0);

297

Output.TexCoord = texCoord;

298

299

return Output;

300

}

301

302

303

304

// Pixel shader output structure

305

struct PS_OUTPUT

306

{

307

float4 RGBColor : COLOR0; // Pixel color

308

};

309

310

311

sampler2D tex0;

312

313

PS_OUTPUT pixelMain( float2 TexCoord : TEXCOORD0,

314

float4 Position : POSITION,

315

float4 Diffuse : COLOR0 )

316

{

317

PS_OUTPUT Output;

318

319

float4 col = tex2D( tex0, TexCoord ); // sample color map

320

321

// multiply with diffuse and do other senseless operations

322

Output.RGBColor = Diffuse * col;

323

Output.RGBColor *= 4.0;

324

325

return Output;

326

}</pre></td>

327

</tr>

328

</table>

329

330

331

<tr>

332

333

</tr>

334

<tr>

335

336

; part of the Irrlicht Engine Shader example.

337

; This Direct3D9 vertex shader will be loaded by the engine.

338

; Please note that these example shaders don't do anything really useful.

339

; They only demonstrate that shaders can be used in Irrlicht.

340

vs.1.1

341

342

dcl_position v0; ; declare position

343

dcl_normal v1; ; declare normal

344

dcl_color v2; ; declare color

345

dcl_texcoord0 v3; ; declare texture coordinate

346

; transpose and transform position to clip space

347

mul r0, v0.x, c4

348

mad r0, v0.y, c5, r0

349

mad r0, v0.z, c6, r0

350

add oPos, c7, r0

351

352

; transform normal

353

dp3 r1.x, v1, c0

354

dp3 r1.y, v1, c1

355

dp3 r1.z, v1, c2

356

357

; renormalize normal

358

dp3 r1.w, r1, r1

359

rsq r1.w, r1.w

360

mul r1, r1, r1.w

361

362

; calculate light vector

363

m4x4 r6, v0, c10 ; vertex into world position

364

add r2, c8, -r6 ; vtxpos - lightpos

365

366

; normalize light vector

367

dp3 r2.w, r2, r2

368

rsq r2.w, r2.w

369

mul r2, r2, r2.w

370

371

; calculate light color

372

dp3 r3, r1, r2 ; dp3 with negative light vector

373

lit r5, r3 ; clamp to zero if r3 < 0, r5 has diffuce component in r5.y

374

mul oD0, r5.y, c9 ; ouput diffuse color

375

mov oT0, v3 ; store texture coordinates </pre> </td>

376

</tr>

377

</table>

378

379

380

<tr>

381

382

</tr>

383

<tr>

384

385

; part of the Irrlicht Engine Shader example.

386

; This simple Direct3D9 pixel shader will be loaded by the engine.

387

; Please note that these example shaders don't do anything really useful.

388

; They only demonstrate that shaders can be used in Irrlicht.

389

ps.1.1

390

391

tex t0 ; sample color map

392

add r0, v0, v0 ; mulitply with color

393

mul t0, t0, r0 ; mulitply with color

394

add r0, t0, t0 ; make it brighter and store result

395

</pre> </td>

396

</tr>

397

</table>

398

399

400

<tr>

401

402

</tr>

403

<tr>

404

405

; part of the Irrlicht Engine Shader example.

406

; This Direct3D9 vertex shader will be loaded by the engine.

407

; Please note that these example shaders don't do anything really useful.

408

; They only demonstrate that shaders can be used in Irrlicht.

409

vs.1.1

410

411

; transpose and transform position to clip space

412

mul r0, v0.x, c4

413

mad r0, v0.y, c5, r0

414

mad r0, v0.z, c6, r0

415

add oPos, c7, r0

416

417

; transform normal

418

dp3 r1.x, v1, c0

419

dp3 r1.y, v1, c1

420

dp3 r1.z, v1, c2

421

422

; renormalize normal

423

dp3 r1.w, r1, r1

424

rsq r1.w, r1.w

425

mul r1, r1, r1.w

426

427

; calculate light vector

428

m4x4 r6, v0, c10 ; vertex into world position

429

add r2, c8, -r6 ; vtxpos - lightpos

430

431

; normalize light vector

432

dp3 r2.w, r2, r2

433

rsq r2.w, r2.w

434

mul r2, r2, r2.w

435

436

; calculate light color

437

dp3 r3, r1, r2 ; dp3 with negative light vector

438

lit r5, r3 ; clamp to zero if r3 < 0, r5 has diffuce component in r5.y

439

mul oD0, r5.y, c9 ; ouput diffuse color

440

mov oT0, v3 ; store texture coordinates </pre> </td>

441

</tr>

442

</table>

443

444

445

<tr>

446

447

</tr>

448

<tr>

449

450

; part of the Irrlicht Engine Shader example.

451

; This simple Direct3D9 pixel shader will be loaded by the engine.

452

; Please note that these example shaders don't do anything really useful.

453

; They only demonstrate that shaders can be used in Irrlicht.

454

ps.1.1

455

456

tex t0 ; sample color map

457

mul_x2 t0, t0, v0 ; mulitply with color

458

add r0, t0, t0 ; make it brighter and store result </pre> </td>

459

</tr>

460

</table>

461

462

463

<tr>

464

<td>OPENGL.VSH</td>

465

</tr>

466

<tr>

467

468

!!ARBvp1.0

469

# part of the Irrlicht Engine Shader example.

470

# Please note that these example shaders don't do anything really useful.

471

# They only demonstrate that shaders can be used in Irrlicht.

472

#input

473

ATTRIB InPos = vertex.position;

474

ATTRIB InColor = vertex.color;

475

ATTRIB InNormal = vertex.normal;

476

ATTRIB InTexCoord = vertex.texcoord;

477

478

#output

479

OUTPUT OutPos = result.position;

480

OUTPUT OutColor = result.color;

481

OUTPUT OutTexCoord = result.texcoord;

482

483

PARAM MVP[4] = { state.matrix.mvp }; # modelViewProjection matrix.

484

TEMP Temp;

485

TEMP TempColor;

486

TEMP TempNormal;

487

TEMP TempPos;

488

489

#transform position to clip space

490

DP4 Temp.x, MVP[0], InPos;

491

DP4 Temp.y, MVP[1], InPos;

492

DP4 Temp.z, MVP[2], InPos;

493

DP4 Temp.w, MVP[3], InPos;

494

495

#transform normal

496

DP3 TempNormal.x, InNormal.x, program.local[0];

497

DP3 TempNormal.y, InNormal.y, program.local[1];

498

DP3 TempNormal.z, InNormal.z, program.local[2];

499

500

#renormalize normal

501

DP3 TempNormal.w, TempNormal, TempNormal;

502

RSQ TempNormal.w, TempNormal.w;

503

MUL TempNormal, TempNormal, TempNormal.w;

504

505

# calculate light vector

506

DP4 TempPos.x, InPos, program.local[10]; # vertex into world position

507

DP4 TempPos.y, InPos, program.local[11];

508

DP4 TempPos.z, InPos, program.local[12];

509

DP4 TempPos.w, InPos, program.local[13];

510

511

ADD TempPos, program.local[8], -TempPos; # vtxpos - lightpos

512

513

# normalize light vector

514

DP3 TempPos.w, TempPos, TempPos;

515

RSQ TempPos.w, TempPos.w;

516

MUL TempPos, TempPos, TempPos.w;

517

518

# calculate light color

519

DP3 TempColor, TempNormal, TempPos; # dp3 with negative light vector

520

LIT OutColor, TempColor; # clamp to zero if r3 < 0, r5 has diffuce component in r5.y

521

MUL OutColor, TempColor.y, program.local[9]; # ouput diffuse color

522

MOV OutColor.w, 1.0; # we want alpha to be always 1

523

MOV OutTexCoord, InTexCoord; # store texture coordinate

524

MOV OutPos, Temp;

525

526

END</pre> </td>

527

</tr>

528

</table>

529

530

531

<tr>

532

<td>OPENGL.PSH</td>

533

</tr>

534

<tr>

535

536

!!ARBfp1.0

537

# part of the Irrlicht Engine Shader example.

538

# Please note that these example shaders don't do anything really useful.

539

# They only demonstrate that shaders can be used in Irrlicht.

540

#Input

541

ATTRIB inTexCoord = fragment.texcoord; # texture coordinates

542

ATTRIB inColor = fragment.color.primary; # interpolated diffuse color

543

544

#Output

545

OUTPUT outColor = result.color;

546

547

TEMP texelColor;

548

TEMP tmp;

549

TXP texelColor, inTexCoord, texture, 2D;

550

551

ADD tmp, inColor, inColor; # mulitply with color

552

MUL texelColor, texelColor, tmp; # mulitply with color

553

ADD outColor, texelColor, texelColor; # make it brighter and store result

554

555

END </pre> </td>

556

</tr>

557

</table>

558

559

</div>

560

</div></td>

561

</tr>

562

</table>

563

564

565

</body>

566

</html>

Older »