src/Radiance/libRAD/libRAD.cpp

   1 // SwiftShader Software Renderer\r
   2 //\r
   3 // Copyright(c) 2014 Google Inc.\r
   4 //\r
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
   6 // transcribed, stored in a retrieval system, translated into any human or computer\r
   7 // language by any means, or disclosed to third parties without the explicit written\r
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
   9 // or implied, including but not limited to any patent rights, are granted to you.\r
  10 //\r
  11 // libRAD.cpp: Implements the exported Radiance functions.\r
  12 \r
  13 #include "main.h"\r
  14 #include "Buffer.h"\r
  15 #include "Context.h"\r
  16 #include "Program.h"\r
  17 #include "Shader.h"\r
  18 #include "Texture.h"\r
  19 #include "common/debug.h"\r
  20 #include "Common/Version.h"\r
  21 #include "Main/Register.hpp"\r
  22 #include "../libEGL/Surface.h"\r
  23 \r
  24 #define GL_APICALL\r
  25 #include <RAD/rad.h>\r
  26 \r
  27 #include <limits>\r
  28 #include <deque>\r
  29 #include <set>\r
  30 \r
  31 namespace rad\r
  32 {\r
  33 class Object;\r
  34 typedef std::set<const Object*> ObjectPool;\r
  35 \r
  36 class Device\r
  37 {\r
  38 public:\r
  39         Device()\r
  40         {\r
  41                 referenceCount = 1;\r
  42         }\r
  43 \r
  44         void reference()\r
  45         {\r
  46                 sw::atomicIncrement(&referenceCount);\r
  47         }\r
  48 \r
  49         void release()\r
  50         {\r
  51                 ASSERT(referenceCount > 0);\r
  52 \r
  53                 if(referenceCount > 0)\r
  54                 {\r
  55                         sw::atomicDecrement(&referenceCount);\r
  56                 }\r
  57 \r
  58                 if(referenceCount == 0)\r
  59                 {\r
  60                         delete this;\r
  61                 }\r
  62         }\r
  63 \r
  64         void addObject(const Object *object)\r
  65         {\r
  66                 pool.insert(object);\r
  67         }\r
  68 \r
  69         void removeObject(const Object *object)\r
  70         {\r
  71                 pool.erase(object);\r
  72         }\r
  73 \r
  74 private:\r
  75         virtual ~Device()\r
  76         {\r
  77                 ASSERT(referenceCount == 0);\r
  78 \r
  79                 size_t leakedObjectCount = pool.size();\r
  80 \r
  81                 if(leakedObjectCount != 0)\r
  82                 {\r
  83                         const Object *leakedObject = *pool.begin();\r
  84                         ASSERT(!leakedObject);\r
  85                 }\r
  86         }\r
  87 \r
  88         volatile int referenceCount;\r
  89 \r
  90         ObjectPool pool;\r
  91 };\r
  92 \r
  93 class Object\r
  94 {\r
  95 public:\r
  96         Object(Device *device) : device(device)\r
  97         {\r
  98                 referenceCount = 1;\r
  99 \r
 100                 device->addObject(this);\r
 101         }\r
 102 \r
 103         void reference()\r
 104         {\r
 105                 sw::atomicIncrement(&referenceCount);\r
 106         }\r
 107 \r
 108         void release()\r
 109         {\r
 110                 ASSERT(referenceCount > 0);\r
 111 \r
 112                 if(referenceCount > 0)\r
 113                 {\r
 114                         sw::atomicDecrement(&referenceCount);\r
 115                 }\r
 116 \r
 117                 if(referenceCount == 0)\r
 118                 {\r
 119                         device->removeObject(this);\r
 120 \r
 121                         delete this;\r
 122                 }\r
 123         }\r
 124 \r
 125 protected:\r
 126         virtual ~Object()\r
 127         {\r
 128                 ASSERT(referenceCount == 0);\r
 129         }\r
 130 \r
 131         Device *const device;\r
 132 \r
 133 private:\r
 134         volatile int referenceCount;\r
 135 };\r
 136 \r
 137 static void Release(Object *object)\r
 138 {\r
 139         if(object)\r
 140         {\r
 141                 object->release();\r
 142         }\r
 143 }\r
 144 \r
 145 class Buffer : public Object\r
 146 {\r
 147 public:\r
 148         Buffer(Device *device) : Object(device)\r
 149         {\r
 150                 buffer = nullptr;\r
 151                 access = 0;      // FIXME: default?\r
 152                 mapAccess = 0;   // FIXME: default?\r
 153         }\r
 154 \r
 155         virtual ~Buffer()\r
 156         {\r
 157                 if(buffer)\r
 158                 {\r
 159                         buffer->release();\r
 160                 }\r
 161         }\r
 162 \r
 163         void storage(RADsizei size)\r
 164         {\r
 165                 ASSERT(!buffer);\r
 166                 buffer = new es2::Buffer(0);\r
 167                 buffer->addRef();\r
 168                 buffer->mContents = new sw::Resource(size);\r
 169                 buffer->mSize = size;\r
 170         }\r
 171 \r
 172         void *map()\r
 173         {\r
 174                 ASSERT(buffer);\r
 175                 return const_cast<void*>(buffer->data());\r
 176         }\r
 177 \r
 178         es2::Buffer *buffer;\r
 179 \r
 180         RADbitfield access;\r
 181         RADbitfield mapAccess;\r
 182 };\r
 183 \r
 184 class Sampler : public Object\r
 185 {\r
 186 public:\r
 187         Sampler(Device *device) : Object(device)\r
 188         {\r
 189                 default();\r
 190         }\r
 191 \r
 192         virtual ~Sampler()\r
 193         {\r
 194         }\r
 195 \r
 196         void default()\r
 197         {\r
 198                 minFilter = RAD_MIN_FILTER_NEAREST_MIPMAP_LINEAR;   // FIXME: default?\r
 199                 magFilter = RAD_MAG_FILTER_LINEAR;                  // FIXME: default?\r
 200 \r
 201                 wrapModeS = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
 202                 wrapModeT = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
 203                 wrapModeR = RAD_WRAP_MODE_REPEAT;   // FIXME: default?\r
 204 \r
 205                 minLod = -1000.0f;   // FIXME: default?\r
 206                 maxLod = 1000.0f;   // FIXME: default?\r
 207                 lodBias = 0.0f;\r
 208                 compareMode = RAD_COMPARE_MODE_NONE;\r
 209                 compareFunc = RAD_COMPARE_FUNC_LEQUAL;   // FIXME: default?\r
 210                 borderColor[0] = 0.0f;   // FIXME: default?\r
 211                 borderColor[1] = 0.0f;   // FIXME: default?\r
 212                 borderColor[2] = 0.0f;   // FIXME: default?\r
 213                 borderColor[3] = 0.0f;   // FIXME: default?\r
 214                 borderColorInt[0] = 0;   // FIXME: default?\r
 215                 borderColorInt[1] = 0;   // FIXME: default?\r
 216                 borderColorInt[2] = 0;   // FIXME: default?\r
 217                 borderColorInt[3] = 0;   // FIXME: default?\r
 218         }\r
 219 \r
 220         RADminFilter minFilter;\r
 221         RADmagFilter magFilter;\r
 222 \r
 223         RADwrapMode wrapModeS;\r
 224         RADwrapMode wrapModeT;\r
 225         RADwrapMode wrapModeR;\r
 226 \r
 227         RADfloat minLod;\r
 228         RADfloat maxLod;\r
 229         RADfloat lodBias;\r
 230         RADcompareMode compareMode;\r
 231         RADcompareFunc compareFunc;\r
 232         RADfloat borderColor[4];\r
 233         RADuint borderColorInt[4];\r
 234 };\r
 235 \r
 236 class Texture;\r
 237 \r
 238 struct TextureSampler\r
 239 {\r
 240         TextureSampler(Texture *texture, Sampler *sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers);\r
 241 \r
 242         virtual TextureSampler::~TextureSampler();\r
 243 \r
 244         Texture *texture;\r
 245         Sampler *sampler;\r
 246         RADtextureTarget target;\r
 247         RADinternalFormat internalFormat;\r
 248         RADuint minLevel;\r
 249         RADuint numLevels;\r
 250         RADuint minLayer;\r
 251         RADuint numLayers;\r
 252 };\r
 253 \r
 254 class Texture : public Object\r
 255 {\r
 256 public:\r
 257         Texture(Device *device) : Object(device)\r
 258         {\r
 259                 texture = nullptr;\r
 260                 access = 0;   // FIXME: default?\r
 261                 //target = 0;\r
 262                 //levels = 0;\r
 263                 //internalFormat = 0;\r
 264                 //width = 0;\r
 265                 //height = 0;\r
 266                 //depth = 0;\r
 267                 //samples = 0;\r
 268         }\r
 269 \r
 270         virtual ~Texture()\r
 271         {\r
 272                 if(texture)\r
 273                 {\r
 274                         texture->release();\r
 275                 }\r
 276 \r
 277                 for(size_t i = 0; i < textureSamplers.size(); i++)\r
 278                 {\r
 279                         delete textureSamplers[i];\r
 280                 }\r
 281         }\r
 282 \r
 283         es2::Texture *texture;\r
 284 \r
 285         RADbitfield access;\r
 286 \r
 287         RADtextureTarget target;\r
 288         RADsizei levels;\r
 289         RADinternalFormat internalFormat;\r
 290         RADsizei width;\r
 291         RADsizei height;\r
 292         RADsizei depth;\r
 293         RADsizei samples;\r
 294 \r
 295         std::vector<TextureSampler*> textureSamplers;\r
 296 };\r
 297 \r
 298 TextureSampler::TextureSampler(Texture *texture, Sampler *sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers)\r
 299 {\r
 300         ASSERT(texture);\r
 301         ASSERT(sampler);\r
 302         //texture->reference();\r
 303         this->texture = texture;\r
 304         //sampler->reference();\r
 305         this->sampler = sampler;\r
 306         this->target = target;\r
 307         this->internalFormat = internalFormat;\r
 308         this->minLevel = minLevel;\r
 309         this->numLevels = numLevels;\r
 310         this->minLayer = minLayer;\r
 311         this->numLayers = numLayers;\r
 312 }\r
 313 \r
 314 TextureSampler::~TextureSampler()\r
 315 {\r
 316         //texture->release();\r
 317         //sampler->release();\r
 318 }\r
 319 \r
 320 class Pass;\r
 321 \r
 322 class Program : public Object\r
 323 {\r
 324 public:\r
 325         Program(Device *device) : Object(device)\r
 326         {\r
 327                 program = new es2::Program(nullptr, 0);\r
 328         }\r
 329 \r
 330         virtual ~Program()\r
 331         {\r
 332                 program->release();\r
 333         }\r
 334 \r
 335         es2::Program *program;\r
 336 };\r
 337 \r
 338 template<typename T, size_t n>\r
 339 inline size_t arraySize(T(&)[n])\r
 340 {\r
 341         return n;\r
 342 }\r
 343 \r
 344 const int RAD_MAX_COLOR_TARGETS = 1;\r
 345 \r
 346 struct ColorState : public Object\r
 347 {\r
 348         ColorState(Device *device) : Object(device)\r
 349         {\r
 350                 default();\r
 351         }\r
 352 \r
 353         void default()\r
 354         {\r
 355                 enable = RAD_FALSE;\r
 356 \r
 357                 for(size_t i = 0; i < arraySize(blend); i++)\r
 358                 {\r
 359                         blend[i].default();\r
 360                 }\r
 361 \r
 362                 numTargets = 1;\r
 363                 logicOpEnable = RAD_FALSE;\r
 364                 logicOp = RAD_LOGIC_OP_COPY;\r
 365                 alphaToCoverageEnable = RAD_FALSE;\r
 366                 blendColor[0] = 0.0f;\r
 367                 blendColor[1] = 0.0f;\r
 368                 blendColor[2] = 0.0f;\r
 369                 blendColor[3] = 0.0f;\r
 370         }\r
 371 \r
 372         RADboolean enable;\r
 373         \r
 374         struct Blend\r
 375         {\r
 376                 Blend()\r
 377                 {\r
 378                         default();\r
 379                 }\r
 380 \r
 381                 void default()\r
 382                 {\r
 383                         enable = RAD_FALSE;\r
 384                         srcFunc = RAD_BLEND_FUNC_ONE;\r
 385                         dstFunc = RAD_BLEND_FUNC_ZERO;\r
 386                         srcFuncAlpha = RAD_BLEND_FUNC_ONE;\r
 387                         dstFuncAlpha = RAD_BLEND_FUNC_ZERO;\r
 388                         modeRGB = RAD_BLEND_EQUATION_ADD;\r
 389                         modeAlpha = RAD_BLEND_EQUATION_ADD;\r
 390                         maskRGBA[0] = RAD_TRUE;\r
 391                         maskRGBA[1] = RAD_TRUE;\r
 392                         maskRGBA[2] = RAD_TRUE;\r
 393                         maskRGBA[3] = RAD_TRUE;\r
 394                 }\r
 395 \r
 396                 RADboolean enable;\r
 397                 RADblendFunc srcFunc;\r
 398                 RADblendFunc dstFunc;\r
 399                 RADblendFunc srcFuncAlpha;\r
 400                 RADblendFunc dstFuncAlpha;\r
 401                 RADblendEquation modeRGB;\r
 402                 RADblendEquation modeAlpha;\r
 403                 RADboolean maskRGBA[4];\r
 404         };\r
 405 \r
 406         Blend blend[RAD_MAX_COLOR_TARGETS];\r
 407 \r
 408         RADuint numTargets;\r
 409         RADboolean logicOpEnable;\r
 410         RADlogicOp logicOp;\r
 411         RADboolean alphaToCoverageEnable;\r
 412         RADfloat blendColor[4];\r
 413 };\r
 414 \r
 415 struct RasterState : public Object\r
 416 {\r
 417         RasterState(Device *device) : Object(device)\r
 418         {\r
 419                 default();\r
 420         }\r
 421 \r
 422         void default()\r
 423         {\r
 424                 pointSize = 1.0f;\r
 425                 lineWidth = 1.0f;\r
 426                 cullFace = RAD_FACE_NONE;\r
 427                 frontFace = RAD_FRONT_FACE_CW;\r
 428                 polygonMode = RAD_POLYGON_MODE_FILL;\r
 429         \r
 430                 offsetFactor = 0.0f;\r
 431                 offsetUnits = 0.0f;\r
 432                 offsetClamp = 0.0f;\r
 433 \r
 434                 polygonOffsetEnables = RAD_POLYGON_OFFSET_NONE;\r
 435                 discardEnable = RAD_FALSE;\r
 436                 multisampleEnable = RAD_TRUE;\r
 437 \r
 438                 samples = 0;\r
 439                 sampleMask = ~0;\r
 440         }\r
 441 \r
 442         RADfloat pointSize;\r
 443         RADfloat lineWidth;\r
 444         RADfaceBitfield cullFace;\r
 445         RADfrontFace frontFace;\r
 446         RADpolygonMode polygonMode;\r
 447         \r
 448         RADfloat offsetFactor;\r
 449         RADfloat offsetUnits;\r
 450         RADfloat offsetClamp;\r
 451 \r
 452         RADpolygonOffsetEnables polygonOffsetEnables;\r
 453         RADboolean discardEnable;\r
 454         RADboolean multisampleEnable;\r
 455 \r
 456         RADuint samples;\r
 457         RADuint sampleMask;\r
 458 };\r
 459 \r
 460 struct DepthStencilState : public Object\r
 461 {\r
 462         DepthStencilState(Device *device) : Object(device)\r
 463         {\r
 464                 default();\r
 465         }\r
 466 \r
 467         void default()\r
 468         {\r
 469                 depthTestEnable = RAD_FALSE;\r
 470                 depthWriteEnable = RAD_FALSE;\r
 471                 depthFunc = RAD_DEPTH_FUNC_LESS;\r
 472                 stencilTestEnable = RAD_FALSE;\r
 473 \r
 474                 stencilFuncFront = RAD_STENCIL_FUNC_ALWAYS;\r
 475                 stencilRefFront = 0;\r
 476                 stencilMaskFront = ~0;\r
 477 \r
 478                 stencilFuncBack = RAD_STENCIL_FUNC_ALWAYS;\r
 479                 stencilRefBack = 0;\r
 480                 stencilMaskBack = ~0;\r
 481 \r
 482                 stencilFailOpFront = RAD_STENCIL_OP_KEEP;\r
 483                 depthFailOpFront = RAD_STENCIL_OP_KEEP;\r
 484                 depthPassOpFront = RAD_STENCIL_OP_KEEP;\r
 485 \r
 486                 stencilFailOpBack = RAD_STENCIL_OP_KEEP;\r
 487                 depthFailOpBack = RAD_STENCIL_OP_KEEP;\r
 488                 depthPassOpBack = RAD_STENCIL_OP_KEEP;\r
 489 \r
 490                 stencilWriteMaskFront = ~0;\r
 491                 stencilWriteMaskBack = ~0;\r
 492         }\r
 493 \r
 494         RADboolean depthTestEnable;\r
 495         RADboolean depthWriteEnable;\r
 496         RADdepthFunc depthFunc;\r
 497         RADboolean stencilTestEnable;\r
 498         \r
 499         RADstencilFunc stencilFuncFront;\r
 500         RADint stencilRefFront;\r
 501         RADuint stencilMaskFront;\r
 502 \r
 503         RADstencilFunc stencilFuncBack;\r
 504         RADint stencilRefBack;\r
 505         RADuint stencilMaskBack;\r
 506 \r
 507         RADstencilOp stencilFailOpFront;\r
 508         RADstencilOp depthFailOpFront;\r
 509         RADstencilOp depthPassOpFront;\r
 510 \r
 511         RADstencilOp stencilFailOpBack;\r
 512         RADstencilOp depthFailOpBack;\r
 513         RADstencilOp depthPassOpBack;\r
 514 \r
 515         RADuint stencilWriteMaskFront;\r
 516         RADuint stencilWriteMaskBack;\r
 517 };\r
 518 \r
 519 const int RAD_MAX_VERTEX_ATTRIB = 16;\r
 520 const int RAD_MAX_VERTEX_BINDING = 16;\r
 521 \r
 522 struct VertexState : public Object\r
 523 {\r
 524         VertexState(Device *device) : Object(device)\r
 525         {\r
 526                 default();\r
 527         }\r
 528 \r
 529         void default()\r
 530         {\r
 531                 for(size_t i = 0; i < arraySize(attrib); i++)\r
 532                 {\r
 533                         attrib[i].default();\r
 534                 }\r
 535 \r
 536                 for(size_t i = 0; i < arraySize(binding); i++)\r
 537                 {\r
 538                         binding[i].default();\r
 539                 }\r
 540         }\r
 541 \r
 542         struct Attribute\r
 543         {\r
 544                 Attribute()\r
 545                 {\r
 546                         default();\r
 547                 }\r
 548 \r
 549                 void default()\r
 550                 {\r
 551                         enable = RAD_FALSE;\r
 552                         bindingIndex = 0;\r
 553                         numComponents = 0;\r
 554                         bytesPerComponent = 0;\r
 555                         type = RAD_ATTRIB_TYPE_SNORM;\r
 556                         relativeOffset = 0;\r
 557                 }\r
 558 \r
 559                 RADboolean enable;\r
 560                 \r
 561                 RADint bindingIndex;\r
 562                 \r
 563                 RADint numComponents;\r
 564                 RADint bytesPerComponent;\r
 565                 RADattribType type;\r
 566                 RADuint relativeOffset;\r
 567         };\r
 568 \r
 569         Attribute attrib[RAD_MAX_VERTEX_ATTRIB];\r
 570 \r
 571         struct Binding\r
 572         {\r
 573                 Binding()\r
 574                 {\r
 575                         default();\r
 576                 }\r
 577 \r
 578                 void default()\r
 579                 {\r
 580                         group = 0;\r
 581                         index = 0;\r
 582                         stride = 0;\r
 583                 }\r
 584 \r
 585                 RADint group;\r
 586                 RADint index;\r
 587 \r
 588                 RADuint stride;\r
 589         };\r
 590 \r
 591         Binding binding[RAD_MAX_VERTEX_BINDING];\r
 592 };\r
 593 \r
 594 struct FormatState : public Object\r
 595 {\r
 596         FormatState(Device *device) : Object(device)\r
 597         {\r
 598                 default();\r
 599         }\r
 600 \r
 601         void default()\r
 602         {\r
 603                 for(size_t i = 0; i < arraySize(colorFormat); i++)\r
 604                 {\r
 605                         colorFormat[i] = RAD_FORMAT_NONE;\r
 606                 }\r
 607 \r
 608                 depthFormat = RAD_FORMAT_NONE;\r
 609                 stencilFormat = RAD_FORMAT_NONE;\r
 610                 colorSamples = 0;\r
 611                 depthStencilSamples = 0;\r
 612         }\r
 613 \r
 614         RADinternalFormat colorFormat[RAD_MAX_COLOR_TARGETS];\r
 615         RADinternalFormat depthFormat;\r
 616         RADinternalFormat stencilFormat;\r
 617         RADuint colorSamples;\r
 618         RADuint depthStencilSamples;\r
 619 };\r
 620 \r
 621 class Pipeline : public Object\r
 622 {\r
 623 public:\r
 624         Pipeline(Device *device) : Object(device)\r
 625         {\r
 626                 vertexProgram = nullptr;\r
 627                 fragmentProgram = nullptr;\r
 628                 vertexState = nullptr;\r
 629                 colorState = nullptr;\r
 630                 rasterState = nullptr;\r
 631                 depthStencilState = nullptr;\r
 632                 formatState = nullptr;\r
 633                 primitiveType = RAD_TRIANGLES;\r
 634         }\r
 635 \r
 636         virtual ~Pipeline()\r
 637         {\r
 638                 Release(vertexProgram);\r
 639                 Release(fragmentProgram);\r
 640                 Release(vertexState);\r
 641                 Release(colorState);\r
 642                 Release(rasterState);\r
 643                 Release(depthStencilState);\r
 644                 Release(formatState);\r
 645         }\r
 646 \r
 647         Program *vertexProgram;\r
 648         Program *fragmentProgram;\r
 649         VertexState *vertexState;\r
 650         ColorState *colorState;\r
 651         RasterState *rasterState;\r
 652         DepthStencilState *depthStencilState;\r
 653         FormatState *formatState;\r
 654         RADprimitiveType primitiveType;\r
 655 };\r
 656 \r
 657 const int RAD_MAX_ATTACHMENTS = 1 /*depth*/ + 1 /*stencil*/ + RAD_MAX_COLOR_TARGETS;\r
 658 \r
 659 class Pass : public Object\r
 660 {\r
 661 public:\r
 662         Pass(Device *device) : Object(device)\r
 663         {\r
 664                 default();\r
 665         }\r
 666 \r
 667         virtual ~Pass()\r
 668         {\r
 669                 for(size_t i = 0; i < arraySize(colorTarget); i++)\r
 670                 {\r
 671                         if(colorTarget[i])\r
 672                         {\r
 673                                 colorTarget[i]->release();\r
 674                         }\r
 675                 }\r
 676 \r
 677                 if(depthTarget)\r
 678                 {\r
 679                         depthTarget->release();\r
 680                 }\r
 681 \r
 682                 if(stencilTarget)\r
 683                 {\r
 684                         stencilTarget->release();\r
 685                 }\r
 686         }\r
 687 \r
 688         void default()\r
 689         {\r
 690                 numColors = 0;\r
 691 \r
 692                 for(size_t i = 0; i < arraySize(colorTarget); i++)\r
 693                 {\r
 694                         colorTarget[i] = nullptr;\r
 695                 }\r
 696 \r
 697                 depthTarget = nullptr;\r
 698                 stencilTarget = nullptr;\r
 699 \r
 700                 for(size_t i = 0; i < arraySize(preserveEnable); i++)\r
 701                 {\r
 702                         preserveEnable[i] = RAD_TRUE;\r
 703                 }\r
 704         }\r
 705 \r
 706         RADuint numColors;\r
 707         es2::Image *colorTarget[RAD_MAX_COLOR_TARGETS];\r
 708         es2::Image *depthTarget;\r
 709         es2::Image *stencilTarget;\r
 710 \r
 711         RADboolean preserveEnable[RAD_MAX_ATTACHMENTS];\r
 712 \r
 713         //RADuint numDiscardTextures;\r
 714         //const RADtexture *discardTextures;\r
 715         //const RADoffset2D *discardOffsets;\r
 716         //\r
 717         //RADtexture resolveTexture[RAD_MAX_ATTACHMENTS];\r
 718 \r
 719         //RADuint numStoreTextures;\r
 720         //const RADtexture *storeTextures;\r
 721         //const RADoffset2D *storeOffsets;\r
 722         //\r
 723         //const RADrect2D *clipRect;\r
 724 \r
 725         //RADuint numDependencies;\r
 726         //const RADpass *dependentPasses;\r
 727         //const RADbitfield *srcMask;\r
 728         //const RADbitfield *dstMask;\r
 729         //const RADbitfield *flushMask;\r
 730         //const RADbitfield *invalidateMask;\r
 731 \r
 732         //RADboolean tilingBoundary;\r
 733 \r
 734         //RADuint tileFilterWidth;\r
 735         //RADuint tileTilterHeight;\r
 736 \r
 737         //RADuint bytesPerPixel;\r
 738         //RADuint footprintFilterWidth;\r
 739         //RADuint footprintFilterHeight;\r
 740 };\r
 741 \r
 742 class Command\r
 743 {\r
 744 public:\r
 745         Command()\r
 746         {\r
 747                 //pipeline = nullptr;\r
 748                 //pass = nullptr;\r
 749         }\r
 750 \r
 751         virtual ~Command()\r
 752         {\r
 753                 //Release(pipeline);\r
 754                 //Release(pass);\r
 755         }\r
 756 \r
 757         virtual void execute(Pipeline *pipeline, Pass *pass) = 0;   // FIXME: Just queue as parameter?\r
 758 \r
 759         virtual bool isPresent() const\r
 760         {\r
 761                 return false;\r
 762         }\r
 763 \r
 764         //void setPipeline(Pipeline *pipeline)\r
 765         //{\r
 766         //      if(pipeline)\r
 767         //      {\r
 768         //              pipeline->reference();\r
 769         //              this->pipeline = pipeline;\r
 770         //      }\r
 771         //}\r
 772 \r
 773         //void setPass(Pass *pass)\r
 774         //{\r
 775         //      if(pass)\r
 776         //      {\r
 777         //              pass->reference();\r
 778         //              this->pass = pass;\r
 779         //      }\r
 780         //}\r
 781 \r
 782 protected:\r
 783         //Pipeline *pipeline;   // FIXME: Command-specific state captured in their constructor?\r
 784         //Pass *pass;\r
 785 };\r
 786 \r
 787 class CopyBufferToImage : public Command\r
 788 {\r
 789 public:\r
 790         CopyBufferToImage(Buffer *buffer, RADintptr bufferOffset, Texture *texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth)\r
 791         {\r
 792                 ASSERT(buffer);\r
 793                 ASSERT(texture);\r
 794                 buffer->reference();\r
 795                 this->buffer = buffer;\r
 796                 this->bufferOffset = bufferOffset;\r
 797                 texture->reference();\r
 798                 this->texture = texture;\r
 799                 this->level = level;\r
 800                 this->xoffset = xoffset;\r
 801                 this->yoffset = yoffset;\r
 802                 this->zoffset = zoffset;\r
 803                 this->width = width;\r
 804                 this->height = height;\r
 805                 this->depth = depth;\r
 806         }\r
 807 \r
 808         virtual ~CopyBufferToImage()\r
 809         {\r
 810                 buffer->release();\r
 811                 texture->release();\r
 812         }\r
 813 \r
 814         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 815         {\r
 816                 ASSERT(depth == 1);   // FIXME: Unimplemented\r
 817                 egl::Image *image = texture->texture->getRenderTarget(GL_TEXTURE_2D, level);\r
 818                 uint8_t *output = static_cast<uint8_t*>(image->lock(xoffset, yoffset, sw::LOCK_WRITEONLY));   // FIXME: Discard if whole image\r
 819                 unsigned int pitch = image->getPitch();\r
 820                 const uint8_t *input = static_cast<const uint8_t*>(buffer->map()) + bufferOffset;   // FIXME: Necessary to lock?\r
 821 \r
 822                 ASSERT(texture->internalFormat == RAD_RGBA8);   // FIXME: Unimplemented\r
 823                 int bytesPerTexel = 4;\r
 824 \r
 825                 for(int y = 0; y < height; y++)\r
 826                 {\r
 827                         const uint8_t *source = input + y * (width * bytesPerTexel);\r
 828                         uint8_t *dest = output + y * pitch;\r
 829 \r
 830                         memcpy(dest, source, width * bytesPerTexel);\r
 831                 }\r
 832 \r
 833                 image->unlock();\r
 834         }\r
 835 \r
 836         Buffer *buffer;\r
 837         RADintptr bufferOffset;\r
 838         Texture *texture;\r
 839         RADint level;\r
 840         RADuint xoffset;\r
 841         RADuint yoffset;\r
 842         RADuint zoffset;\r
 843         RADsizei width;\r
 844         RADsizei height;\r
 845         RADsizei depth;\r
 846 };\r
 847 \r
 848 class Scissor : public Command\r
 849 {\r
 850 public:\r
 851         Scissor(RADint x, RADint y, RADint w, RADint h)\r
 852         {\r
 853                 this->x = x;\r
 854                 this->y = y;\r
 855                 this->w = w;\r
 856                 this->h = h;\r
 857         }\r
 858 \r
 859         virtual ~Scissor()\r
 860         {\r
 861         }\r
 862 \r
 863         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 864         {\r
 865                 es2::Context *context = es2::getContext();\r
 866                 context->setScissorParams(x, y, w, h);\r
 867         }\r
 868 \r
 869         RADint x;\r
 870         RADint y;\r
 871         RADint w;\r
 872         RADint h;\r
 873 };\r
 874 \r
 875 class Viewport : public Command\r
 876 {\r
 877 public:\r
 878         Viewport(RADint x, RADint y, RADint w, RADint h)\r
 879         {\r
 880                 this->x = x;\r
 881                 this->y = y;\r
 882                 this->w = w;\r
 883                 this->h = h;\r
 884         }\r
 885 \r
 886         virtual ~Viewport()\r
 887         {\r
 888         }\r
 889 \r
 890         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 891         {\r
 892                 es2::Context *context = es2::getContext();\r
 893                 context->setViewportParams(x, y, w, h);\r
 894         }\r
 895 \r
 896         RADint x;\r
 897         RADint y;\r
 898         RADint w;\r
 899         RADint h;\r
 900 };\r
 901 \r
 902 class ClearColor : public Command\r
 903 {\r
 904 public:\r
 905         ClearColor(RADuint index, const RADfloat *color)\r
 906         {\r
 907                 this->index = index;\r
 908                 this->color[0] = color[0];\r
 909                 this->color[1] = color[1];\r
 910                 this->color[2] = color[2];\r
 911                 this->color[3] = color[3];\r
 912         }\r
 913 \r
 914         virtual ~ClearColor()\r
 915         {\r
 916         }\r
 917 \r
 918         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 919         {\r
 920                 ASSERT(pass);   // FIXME: Error if no beginPass\r
 921                 ASSERT(index < pass->numColors);\r
 922                 es2::Image *image = pass->colorTarget[index];\r
 923 \r
 924                 GLenum format = image->getFormat();\r
 925                 GLenum type = image->getType();\r
 926                 ASSERT(format == GL_RGBA);   // FIXME\r
 927                 ASSERT(type == GL_UNSIGNED_BYTE);   //  FIXME\r
 928 \r
 929                 es2::Context *context = es2::getContext();\r
 930                 int x0 = context->mState.scissorX;\r
 931                 int y0 = context->mState.scissorY;\r
 932                 int width = context->mState.scissorWidth;\r
 933                 int height = context->mState.scissorHeight;\r
 934 \r
 935                 image->clearColorBuffer(sw::Color<float>(color[0], color[1], color[2], color[3]), 0xF, x0, y0, width, height);\r
 936         }\r
 937 \r
 938         RADuint index;\r
 939         RADfloat color[4];\r
 940 };\r
 941 \r
 942 class ClearDepth : public Command\r
 943 {\r
 944 public:\r
 945         ClearDepth(RADfloat depth)\r
 946         {\r
 947                 this->depth = depth;\r
 948         }\r
 949 \r
 950         virtual ~ClearDepth()\r
 951         {\r
 952         }\r
 953 \r
 954         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 955         {\r
 956                 ASSERT(pass);   // FIXME: Error if no beginPass\r
 957                 es2::Image *image = pass->depthTarget;\r
 958                 \r
 959                 es2::Context *context = es2::getContext();\r
 960                 int x0 = context->mState.scissorX;\r
 961                 int y0 = context->mState.scissorY;\r
 962                 int width = context->mState.scissorWidth;\r
 963                 int height = context->mState.scissorHeight;\r
 964 \r
 965                 image->clearDepthBuffer(depth, x0, y0, width, height);\r
 966         }\r
 967 \r
 968         RADfloat depth;\r
 969 };\r
 970 \r
 971 class Present : public Command\r
 972 {\r
 973 public:\r
 974         Present(Texture *texture)\r
 975         {\r
 976                 texture->reference();\r
 977                 this->texture = texture;\r
 978         }\r
 979 \r
 980         virtual ~Present()\r
 981         {\r
 982                 Release(texture);\r
 983         }\r
 984 \r
 985         virtual void execute(Pipeline *pipeline, Pass *pass)\r
 986         {\r
 987                 es2::Context *context = es2::getContext();\r
 988                 sw::FrameBuffer *frameBuffer = (*es2::getDisplay()->mSurfaceSet.begin())->frameBuffer;\r
 989 \r
 990                 egl::Image *image = texture->texture->getRenderTarget(GL_TEXTURE_2D, 0);\r
 991                 void *source = image->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);\r
 992                 frameBuffer->flip(source, image->getInternalFormat());\r
 993                 image->unlockInternal();\r
 994                 image->release();\r
 995         }\r
 996 \r
 997         virtual bool isPresent() const\r
 998         {\r
 999                 return true;\r
1000         }\r
1001 \r
1002         Texture *texture;\r
1003 };\r
1004 \r
1005 class DrawElements : public Command\r
1006 {\r
1007 public:\r
1008         DrawElements(RADprimitiveType mode, RADindexType type, RADsizei count, es2::Buffer *indexBuffer, RADuint offset)\r
1009         {\r
1010                 this->mode = mode;\r
1011                 this->type = type;\r
1012                 this->count = count;\r
1013                 this->indexBuffer = indexBuffer;\r
1014                 this->offset = offset;\r
1015         }\r
1016 \r
1017         ~DrawElements()\r
1018         {\r
1019         }\r
1020 \r
1021         virtual void execute(Pipeline *pipeline, Pass *pass)\r
1022         {\r
1023                 es2::Context *context = es2::getContext();\r
1024 \r
1025                 ASSERT(pipeline->vertexProgram == pipeline->fragmentProgram);   // FIXME\r
1026                 context->mState.program = pipeline->vertexProgram->program;\r
1027 \r
1028                 GLenum glType = GL_UNSIGNED_SHORT;\r
1029                 switch(type)\r
1030                 {\r
1031                 case RAD_INDEX_UNSIGNED_BYTE:  glType = GL_UNSIGNED_BYTE;  break;\r
1032                 case RAD_INDEX_UNSIGNED_SHORT: glType = GL_UNSIGNED_SHORT; break;\r
1033                 case RAD_INDEX_UNSIGNED_INT:   glType = GL_UNSIGNED_INT;   break;\r
1034                 default: UNREACHABLE();\r
1035                 }\r
1036 \r
1037                 GLenum glMode = GL_TRIANGLES;\r
1038                 switch(mode)\r
1039                 {\r
1040                 case RAD_TRIANGLES: glMode = GL_TRIANGLES; break;\r
1041                 default: UNREACHABLE();\r
1042                 }\r
1043 \r
1044                 context->mState.colorBuffer = pass->colorTarget[0];\r
1045                 context->mState.depthBuffer = pass->depthTarget;\r
1046 \r
1047                 context->mState.depthTest = pipeline->depthStencilState->depthTestEnable;\r
1048 \r
1049                 GLenum glDepth = GL_LESS;\r
1050                 switch(pipeline->depthStencilState->depthFunc)\r
1051                 {\r
1052                 case RAD_DEPTH_FUNC_NEVER:    glDepth = GL_NEVER;    break;\r
1053                 case RAD_DEPTH_FUNC_LESS:     glDepth = GL_LESS;     break;\r
1054                 case RAD_DEPTH_FUNC_EQUAL:    glDepth = GL_EQUAL;    break;\r
1055                 case RAD_DEPTH_FUNC_LEQUAL:   glDepth = GL_LEQUAL;   break;\r
1056                 case RAD_DEPTH_FUNC_GREATER:  glDepth = GL_GREATER;  break;\r
1057                 case RAD_DEPTH_FUNC_NOTEQUAL: glDepth = GL_NOTEQUAL; break;\r
1058                 case RAD_DEPTH_FUNC_GEQUAL:   glDepth = GL_GEQUAL;   break;\r
1059                 case RAD_DEPTH_FUNC_ALWAYS:   glDepth = GL_ALWAYS;   break;\r
1060                 default: UNREACHABLE();\r
1061                 }\r
1062 \r
1063                 context->mState.elementArrayBuffer.set(indexBuffer);\r
1064                 context->drawElements(glMode, count, glType, 0);\r
1065         }\r
1066 \r
1067         RADprimitiveType mode;\r
1068         RADindexType type;\r
1069         RADsizei count;\r
1070         es2::Buffer *indexBuffer;\r
1071         RADuint offset;\r
1072 };\r
1073 \r
1074 class BindGroup : public Command\r
1075 {\r
1076 public:\r
1077         BindGroup(RADbitfield stages, RADuint group, RADuint count, es2::Buffer *buffer, RADuint offset)\r
1078         {\r
1079                 this->stages = stages;\r
1080                 this->group = group;\r
1081                 this->count = count;\r
1082                 this->buffer = buffer;\r
1083                 this->offset = offset;\r
1084         }\r
1085 \r
1086         virtual ~BindGroup()\r
1087         {\r
1088         }\r
1089 \r
1090         virtual void execute(Pipeline *pipeline, Pass *pass)\r
1091         {\r
1092                 es2::Context *context = es2::getContext();\r
1093 \r
1094                 const RADbindGroupElement *groupElements = static_cast<const RADbindGroupElement*>(buffer->data());\r
1095 \r
1096                 // FIXME: Should parse the layout out of the shaders\r
1097                 es2::Program *program = pipeline->vertexProgram->program;\r
1098 \r
1099                 es2::Buffer *element0 = reinterpret_cast<es2::Buffer*>(groupElements[0].handle);\r
1100                 void *offset0 = reinterpret_cast<void*>(static_cast<uintptr_t>(groupElements[0].offset));\r
1101                 int position = program->getAttributeLocation("position");\r
1102                 context->setVertexAttribState(position, element0, 3, GL_FLOAT, GL_TRUE, 0, offset0);\r
1103                 context->setEnableVertexAttribArray(position, true);\r
1104 \r
1105                 es2::Buffer *element1 = reinterpret_cast<es2::Buffer*>(groupElements[1].handle);\r
1106                 void *offset1 = reinterpret_cast<void*>(static_cast<uintptr_t>(groupElements[1].offset));\r
1107                 int tc = program->getAttributeLocation("tc");\r
1108                 context->setVertexAttribState(tc, element1, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, offset1);\r
1109                 context->setEnableVertexAttribArray(tc, true);\r
1110 \r
1111                 es2::Buffer *element2 = reinterpret_cast<es2::Buffer*>(groupElements[2].handle);\r
1112                 const void *uniform = static_cast<const uint8_t*>(element2->data()) + groupElements[2].offset;\r
1113                 int scale = program->getUniformLocation("scale");\r
1114                 program->setUniform4fv(scale, 1, (const GLfloat*)uniform);\r
1115 \r
1116                 rad::TextureSampler *element3 = reinterpret_cast<rad::TextureSampler*>(groupElements[3].handle);\r
1117                 int tex = program->getUniformLocation("tex");\r
1118                 int sampler = 0;\r
1119                 program->setUniform1iv(tex, 1, &sampler);\r
1120                 context->applyTexture(sw::SAMPLER_PIXEL, sampler, element3->texture->texture);\r
1121         }\r
1122 \r
1123         RADbitfield stages;\r
1124         RADuint group;\r
1125         RADuint count;\r
1126         es2::Buffer *buffer;\r
1127         RADuint offset;\r
1128 };\r
1129 \r
1130 class Queue : public Object\r
1131 {\r
1132 public:\r
1133         Queue(Device *device) : Object(device)\r
1134         {\r
1135                 graphicsPipeline = nullptr;\r
1136                 pass = nullptr;\r
1137         }\r
1138 \r
1139         virtual ~Queue()\r
1140         {\r
1141                 for(size_t i = 0; i < commands.size(); i++)\r
1142                 {\r
1143                         delete commands[i];\r
1144                 }\r
1145 \r
1146                 Release(graphicsPipeline);\r
1147 \r
1148                 ASSERT(!pass);   // FIXME: No matching endPass\r
1149                 Release(pass);\r
1150         }\r
1151 \r
1152         void submit(Command *command)\r
1153         {\r
1154                 // FIXME: Make BeginPass/EndPass/BindPipeline commands too?\r
1155                 //command->setPipeline(graphicsPipeline);\r
1156                 //command->setPass(pass);\r
1157 \r
1158                 if(false)   // Queued execution\r
1159                 {\r
1160                         commands.push_back(command);\r
1161 \r
1162                         if(command->isPresent())\r
1163                         {\r
1164                                 // FIXME: Flush\r
1165                         }\r
1166                 }\r
1167                 else   // Immediate execution\r
1168                 {\r
1169                         command->execute(graphicsPipeline, pass);\r
1170 \r
1171                         delete command;\r
1172                 }\r
1173         }\r
1174 \r
1175         void bindPipeline(RADpipelineType pipelineType, Pipeline *pipeline)\r
1176         {\r
1177                 if(pipelineType == RAD_PIPELINE_TYPE_GRAPHICS)\r
1178                 {\r
1179                         pipeline->reference();\r
1180 \r
1181                         if(graphicsPipeline)\r
1182                         {\r
1183                                 graphicsPipeline->release();\r
1184                         }\r
1185 \r
1186                         graphicsPipeline = pipeline;\r
1187                 }\r
1188                 else UNREACHABLE();\r
1189         }\r
1190 \r
1191         void beginPass(rad::Pass *pass)\r
1192         {\r
1193                 ASSERT(!this->pass);   // FIXME: Can be nested?\r
1194                 pass->reference();\r
1195                 this->pass = pass;\r
1196         }\r
1197 \r
1198         void endPass(rad::Pass *pass)\r
1199         {\r
1200                 ASSERT(this->pass == pass);   // FIXME: Can be nested?\r
1201                 this->pass->release();\r
1202                 this->pass = nullptr;\r
1203         }\r
1204 \r
1205 private:\r
1206         std::deque<Command*> commands;\r
1207         Pipeline *graphicsPipeline;\r
1208         Pass *pass;\r
1209 };\r
1210 }\r
1211 \r
1212 extern "C"\r
1213 {\r
1214 RADdevice RADAPIENTRY radCreateDevice(void)\r
1215 {\r
1216         static rad::Device *device = new rad::Device();\r
1217         return reinterpret_cast<RADdevice>(device);\r
1218 }\r
1219 \r
1220 void RADAPIENTRY radReferenceDevice(RADdevice device)\r
1221 {\r
1222         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1223         return radDevice->reference();\r
1224 }\r
1225 void RADAPIENTRY radReleaseDevice(RADdevice device)\r
1226 {\r
1227         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1228         return radDevice->release();\r
1229 }\r
1230 \r
1231 RADuint RADAPIENTRY radGetTokenHeader(RADdevice device, RADtokenName name) {UNIMPLEMENTED(); return 0;}\r
1232 \r
1233 RADqueue RADAPIENTRY radCreateQueue(RADdevice device, RADqueueType queuetype)\r
1234 {\r
1235         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1236         rad::Queue *queue = new rad::Queue(radDevice);\r
1237         return reinterpret_cast<RADqueue>(queue);\r
1238 }\r
1239 \r
1240 void RADAPIENTRY radReferenceQueue(RADqueue queue)\r
1241 {\r
1242         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1243         return radQueue->reference();\r
1244 }\r
1245 \r
1246 void RADAPIENTRY radReleaseQueue(RADqueue queue)\r
1247 {\r
1248         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1249         return radQueue->release();\r
1250 }\r
1251 \r
1252 void RADAPIENTRY radQueueTagBuffer(RADqueue queue, RADbuffer buffer) {UNIMPLEMENTED();}\r
1253 void RADAPIENTRY radQueueTagTexture(RADqueue queue, RADtexture texture) {UNIMPLEMENTED();}\r
1254 \r
1255 void RADAPIENTRY radQueueSubmitCommands(RADqueue queue, RADuint numCommands, const RADcommandHandle *handles)\r
1256 {\r
1257         return;\r
1258 }\r
1259 \r
1260 void RADAPIENTRY radFlushQueue(RADqueue queue) {UNIMPLEMENTED();}\r
1261 void RADAPIENTRY radFinishQueue(RADqueue queue) {UNIMPLEMENTED();}\r
1262 \r
1263 void RADAPIENTRY radQueueViewport(RADqueue queue, RADint x, RADint y, RADint w, RADint h)\r
1264 {\r
1265         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1266         rad::Viewport *command = new rad::Viewport(x, y, w, h);\r
1267         radQueue->submit(command);\r
1268 }\r
1269 \r
1270 void RADAPIENTRY radQueueScissor(RADqueue queue, RADint x, RADint y, RADint w, RADint h)\r
1271 {\r
1272         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1273         rad::Scissor *command = new rad::Scissor(x, y, w, h);\r
1274         radQueue->submit(command);\r
1275 }\r
1276 \r
1277 void RADAPIENTRY radQueueCopyBufferToImage(RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth)\r
1278 {\r
1279         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1280         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1281         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1282         rad::CopyBufferToImage *command = new rad::CopyBufferToImage(radBuffer, bufferOffset, radTexture, level, xoffset, yoffset, zoffset, width, height, depth);\r
1283         radQueue->submit(command);\r
1284 }\r
1285 \r
1286 void RADAPIENTRY radQueueCopyImageToBuffer(RADqueue queue, RADbuffer buffer, RADintptr bufferOffset, RADtexture texture, RADint level, RADuint xoffset, RADuint yoffset, RADuint zoffset, RADsizei width, RADsizei height, RADsizei depth) {UNIMPLEMENTED();}\r
1287 \r
1288 void RADAPIENTRY radQueueCopyBuffer(RADqueue queue, RADbuffer srcBuffer, RADintptr srcOffset, RADbuffer dstBuffer, RADintptr dstOffset, RADsizei size)\r
1289 {\r
1290         return;\r
1291 }\r
1292 \r
1293 void RADAPIENTRY radQueueClearColor(RADqueue queue, RADuint index, const RADfloat *color)\r
1294 {\r
1295         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1296         rad::ClearColor *command = new rad::ClearColor(index, color);\r
1297         radQueue->submit(command);\r
1298 }\r
1299 \r
1300 void RADAPIENTRY radQueueClearDepth(RADqueue queue, RADfloat depth)\r
1301 {\r
1302         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1303         rad::ClearDepth *command = new rad::ClearDepth(depth);\r
1304         radQueue->submit(command);\r
1305 }\r
1306 \r
1307 void RADAPIENTRY radQueueClearStencil(RADqueue queue, RADuint stencil) {UNIMPLEMENTED();}\r
1308 \r
1309 void RADAPIENTRY radQueuePresent(RADqueue queue, RADtexture texture)\r
1310 {\r
1311         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1312         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1313         rad::Present *command = new rad::Present(radTexture);\r
1314         radQueue->submit(command);\r
1315 }\r
1316 \r
1317 void RADAPIENTRY radQueueDrawArrays(RADqueue queue, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
1318 \r
1319 void RADAPIENTRY radQueueDrawElements(RADqueue queue, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset)\r
1320 {\r
1321         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1322         es2::Buffer *indexBuffer = reinterpret_cast<es2::Buffer*>(indexHandle);\r
1323         rad::DrawElements *command = new rad::DrawElements(mode, type, count, indexBuffer, offset);\r
1324         radQueue->submit(command);\r
1325 }\r
1326 \r
1327 void RADAPIENTRY radQueueBindPipeline(RADqueue queue, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle)\r
1328 {\r
1329         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1330         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipelineHandle);\r
1331         radQueue->bindPipeline(pipelineType, radPipeline);\r
1332 }\r
1333 \r
1334 void RADAPIENTRY radQueueBindGroup(RADqueue queue, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset)\r
1335 {\r
1336         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1337         es2::Buffer *groupBuffer = reinterpret_cast<es2::Buffer*>(groupHandle);\r
1338         rad::BindGroup *command = new rad::BindGroup(stages, group, count, groupBuffer, offset);\r
1339         radQueue->submit(command);\r
1340 }\r
1341 \r
1342 void RADAPIENTRY radQueueBeginPass(RADqueue queue, RADpass pass)\r
1343 {\r
1344         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1345         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
1346         radQueue->beginPass(radPass);\r
1347 }\r
1348 \r
1349 void RADAPIENTRY radQueueEndPass(RADqueue queue, RADpass pass)\r
1350 {\r
1351         rad::Queue *radQueue = reinterpret_cast<rad::Queue*>(queue);\r
1352         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
1353         radQueue->endPass(radPass);\r
1354 }\r
1355 \r
1356 void RADAPIENTRY radQueueSubmitDynamic(RADqueue queue, const void *dynamic, RADsizei length) {UNIMPLEMENTED();}\r
1357 void RADAPIENTRY radQueueStencilValueMask(RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
1358 void RADAPIENTRY radQueueStencilMask(RADqueue queue, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
1359 void RADAPIENTRY radQueueStencilRef(RADqueue queue, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
1360 void RADAPIENTRY radQueueBlendColor(RADqueue queue, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
1361 void RADAPIENTRY radQueuePointSize(RADqueue queue, RADfloat pointSize) {UNIMPLEMENTED();}\r
1362 void RADAPIENTRY radQueueLineWidth(RADqueue queue, RADfloat lineWidth) {UNIMPLEMENTED();}\r
1363 void RADAPIENTRY radQueuePolygonOffsetClamp(RADqueue queue, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
1364 void RADAPIENTRY radQueueSampleMask(RADqueue queue, RADuint mask) {UNIMPLEMENTED();}\r
1365 \r
1366 RADprogram RADAPIENTRY radCreateProgram(RADdevice device)\r
1367 {\r
1368         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1369         rad::Program *program = new rad::Program(radDevice);\r
1370         return reinterpret_cast<RADprogram>(program);\r
1371 }\r
1372 \r
1373 void RADAPIENTRY radReferenceProgram(RADprogram program)\r
1374 {\r
1375         rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
1376         radProgram->reference();\r
1377 }\r
1378 \r
1379 void RADAPIENTRY radReleaseProgram(RADprogram program)\r
1380 {\r
1381         rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
1382         radProgram->release();\r
1383 }\r
1384 \r
1385 void RADAPIENTRY radProgramSource(RADprogram program, RADprogramFormat format, RADsizei length, const void *source)\r
1386 {\r
1387         rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
1388 \r
1389         // FIXME: Assumes first source is vertex shader, second is fragment shader\r
1390         ASSERT(length == 2);\r
1391         const char *vertexSource = static_cast<const char* const*>(source)[0];\r
1392         const char *fragmentSource = static_cast<const char* const*>(source)[1];\r
1393         GLint vertexLength = strlen(vertexSource);\r
1394         GLint fragmentLength = strlen(fragmentSource);\r
1395 \r
1396         es2::VertexShader *vertexShader = new es2::VertexShader(nullptr, 0);\r
1397         es2::FragmentShader *fragmentShader = new es2::FragmentShader(nullptr, 0);\r
1398 \r
1399         vertexShader->setSource(1, &vertexSource, &vertexLength);\r
1400         fragmentShader->setSource(1, &fragmentSource, &fragmentLength);\r
1401 \r
1402         vertexShader->compile();\r
1403         fragmentShader->compile();\r
1404 \r
1405         radProgram->program->attachShader(vertexShader);\r
1406         radProgram->program->attachShader(fragmentShader);\r
1407         radProgram->program->link();\r
1408 \r
1409         vertexShader->release();     // Still referenced by program\r
1410         fragmentShader->release();   // Still referenced by program\r
1411 }\r
1412 \r
1413 RADbuffer RADAPIENTRY radCreateBuffer(RADdevice device)\r
1414 {\r
1415         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1416         rad::Buffer *buffer = new rad::Buffer(radDevice);\r
1417         return reinterpret_cast<RADbuffer>(buffer);\r
1418 }\r
1419 \r
1420 void RADAPIENTRY radReferenceBuffer(RADbuffer buffer)\r
1421 {\r
1422         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1423         radBuffer->reference();\r
1424 }\r
1425 \r
1426 void RADAPIENTRY radReleaseBuffer(RADbuffer buffer, RADtagMode tagMode)\r
1427 {\r
1428         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1429         radBuffer->release();\r
1430 }\r
1431 \r
1432 void RADAPIENTRY radBufferAccess(RADbuffer buffer, RADbitfield access)\r
1433 {\r
1434         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1435         radBuffer->access = access;\r
1436 }\r
1437 \r
1438 void RADAPIENTRY radBufferMapAccess(RADbuffer buffer, RADbitfield mapAccess)\r
1439 {\r
1440         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1441         radBuffer->mapAccess = mapAccess;\r
1442 }\r
1443 \r
1444 void RADAPIENTRY radBufferStorage(RADbuffer buffer, RADsizei size)\r
1445 {\r
1446         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1447         radBuffer->storage(size);\r
1448 }\r
1449 \r
1450 void* RADAPIENTRY radMapBuffer(RADbuffer buffer)\r
1451 {\r
1452         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1453         return radBuffer->map();\r
1454 }\r
1455 \r
1456 RADvertexHandle RADAPIENTRY radGetVertexHandle(RADbuffer buffer)\r
1457 {\r
1458         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1459         return reinterpret_cast<RADvertexHandle>(radBuffer->buffer);\r
1460 }\r
1461 \r
1462 RADindexHandle RADAPIENTRY radGetIndexHandle(RADbuffer buffer)\r
1463 {\r
1464         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1465         return reinterpret_cast<RADvertexHandle>(radBuffer->buffer);\r
1466 }\r
1467 \r
1468 RADuniformHandle RADAPIENTRY radGetUniformHandle(RADbuffer buffer)\r
1469 {\r
1470         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1471         return reinterpret_cast<RADuniformHandle>(radBuffer->buffer);\r
1472 }\r
1473 \r
1474 RADbindGroupHandle RADAPIENTRY radGetBindGroupHandle(RADbuffer buffer)\r
1475 {\r
1476         rad::Buffer *radBuffer = reinterpret_cast<rad::Buffer*>(buffer);\r
1477         return reinterpret_cast<RADbindGroupHandle>(radBuffer->buffer);\r
1478 }\r
1479 \r
1480 RADtexture RADAPIENTRY radCreateTexture(RADdevice device)\r
1481 {\r
1482         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1483         rad::Texture *colorState = new rad::Texture(radDevice);\r
1484         return reinterpret_cast<RADtexture>(colorState);\r
1485 }\r
1486 \r
1487 void RADAPIENTRY radReferenceTexture(RADtexture texture)\r
1488 {\r
1489         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1490         radTexture->reference();\r
1491 }\r
1492 \r
1493 void RADAPIENTRY radReleaseTexture(RADtexture texture, RADtagMode tagMode)\r
1494 {\r
1495         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1496         radTexture->release();\r
1497 }\r
1498 \r
1499 void RADAPIENTRY radTextureAccess(RADtexture texture, RADbitfield access)\r
1500 {\r
1501         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1502         radTexture->access = access;\r
1503 }\r
1504 \r
1505 void RADAPIENTRY radTextureStorage(RADtexture texture, RADtextureTarget target, RADsizei levels, RADinternalFormat internalFormat, RADsizei width, RADsizei height, RADsizei depth, RADsizei samples)\r
1506 {\r
1507         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1508         ASSERT(!radTexture->texture);\r
1509 \r
1510         radTexture->target = target;\r
1511         radTexture->levels = levels;\r
1512         radTexture->internalFormat = internalFormat;\r
1513         radTexture->width = width;\r
1514         radTexture->height = height;\r
1515         radTexture->depth = depth;\r
1516         radTexture->samples = samples;\r
1517 \r
1518         GLenum format = GL_NONE;\r
1519         GLenum type = GL_NONE;\r
1520         switch(internalFormat)\r
1521         {\r
1522         case RAD_RGBA8:\r
1523                 format = GL_RGBA;\r
1524                 type = GL_UNSIGNED_BYTE;\r
1525                 break;\r
1526         case RAD_DEPTH24_STENCIL8:\r
1527                 format = GL_DEPTH_STENCIL_OES;\r
1528                 type = GL_UNSIGNED_INT_24_8_OES;\r
1529                 break;\r
1530         default:\r
1531                 UNIMPLEMENTED();   // FIXME\r
1532         }\r
1533 \r
1534         switch(target)\r
1535         {\r
1536         case RAD_TEXTURE_2D:\r
1537                 {\r
1538                         es2::Texture2D *tex = new es2::Texture2D(0);\r
1539                         for(int level = 0; level < levels; level++)\r
1540                         {\r
1541                                 tex->setImage(level, width >> level, height >> level, format, type, 1, nullptr);\r
1542                         }\r
1543                         tex->addRef();\r
1544                         radTexture->texture = tex;\r
1545                 }\r
1546                 break;\r
1547         default:\r
1548                 UNIMPLEMENTED();   // FIXME\r
1549         }\r
1550 }\r
1551 \r
1552 RADtextureHandle RADAPIENTRY radGetTextureSamplerHandle(RADtexture texture, RADsampler sampler, RADtextureTarget target, RADinternalFormat internalFormat, RADuint minLevel, RADuint numLevels, RADuint minLayer, RADuint numLayers)\r
1553 {\r
1554         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1555         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1556         rad::TextureSampler *textureSampler = new rad::TextureSampler(radTexture, radSampler, target, internalFormat, minLevel, numLevels, minLayer, numLayers);\r
1557         radTexture->textureSamplers.push_back(textureSampler);   // FIXME: Check for matching existing textureSampler\r
1558         return reinterpret_cast<RADtextureHandle>(textureSampler);\r
1559 }\r
1560 \r
1561 RADrenderTargetHandle RADAPIENTRY radGetTextureRenderTargetHandle(RADtexture texture, RADtextureTarget target, RADinternalFormat internalFormat, RADuint level, RADuint minLayer, RADuint numLayers)\r
1562 {\r
1563         rad::Texture *radTexture = reinterpret_cast<rad::Texture*>(texture);\r
1564         ASSERT(radTexture->texture);\r
1565         ASSERT(radTexture->internalFormat == internalFormat);\r
1566         ASSERT(minLayer == 0);\r
1567         ASSERT(numLayers == 1);\r
1568         GLenum glTarget = GL_NONE;\r
1569         switch(target)\r
1570         {\r
1571         case RAD_TEXTURE_2D:\r
1572                 glTarget = GL_TEXTURE_2D;\r
1573                 break;\r
1574         default:\r
1575                 UNREACHABLE();\r
1576         }\r
1577         return reinterpret_cast<RADrenderTargetHandle>(radTexture->texture->getRenderTarget(glTarget, level));\r
1578 }\r
1579 \r
1580 RADsampler RADAPIENTRY radCreateSampler(RADdevice device)\r
1581 {\r
1582         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1583         rad::Sampler *sampler = new rad::Sampler(radDevice);\r
1584         return reinterpret_cast<RADsampler>(sampler);\r
1585 }\r
1586 \r
1587 void RADAPIENTRY radReferenceSampler(RADsampler sampler)\r
1588 {\r
1589         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1590         radSampler->reference();\r
1591 }\r
1592 \r
1593 void RADAPIENTRY radReleaseSampler(RADsampler sampler)\r
1594 {\r
1595         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1596         radSampler->release();\r
1597 }\r
1598 \r
1599 void RADAPIENTRY radSamplerDefault(RADsampler sampler)\r
1600 {\r
1601         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1602         radSampler->default();\r
1603 }\r
1604 \r
1605 void RADAPIENTRY radSamplerMinMagFilter(RADsampler sampler, RADminFilter min, RADmagFilter mag)\r
1606 {\r
1607         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1608         radSampler->minFilter = min;\r
1609         radSampler->magFilter = mag;\r
1610 }\r
1611 \r
1612 void RADAPIENTRY radSamplerWrapMode(RADsampler sampler, RADwrapMode s, RADwrapMode t, RADwrapMode r)\r
1613 {\r
1614         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1615         radSampler->wrapModeS = s;\r
1616         radSampler->wrapModeT = t;\r
1617         radSampler->wrapModeR = r;\r
1618 }\r
1619 \r
1620 void RADAPIENTRY radSamplerLodClamp(RADsampler sampler, RADfloat min, RADfloat max)\r
1621 {\r
1622         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1623         radSampler->minLod = min;\r
1624         radSampler->maxLod = max;\r
1625 }\r
1626 \r
1627 void RADAPIENTRY radSamplerLodBias(RADsampler sampler, RADfloat bias)\r
1628 {\r
1629         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1630         radSampler->lodBias = bias;\r
1631 }\r
1632 \r
1633 void RADAPIENTRY radSamplerCompare(RADsampler sampler, RADcompareMode mode, RADcompareFunc func)\r
1634 {\r
1635         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1636         radSampler->compareMode = mode;\r
1637         radSampler->compareFunc = func;\r
1638 }\r
1639 \r
1640 void RADAPIENTRY radSamplerBorderColorFloat(RADsampler sampler, const RADfloat *borderColor)\r
1641 {\r
1642         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1643         radSampler->borderColor[0] = borderColor[0];\r
1644         radSampler->borderColor[1] = borderColor[1];\r
1645         radSampler->borderColor[2] = borderColor[2];\r
1646         radSampler->borderColor[3] = borderColor[3];\r
1647 }\r
1648 \r
1649 void RADAPIENTRY radSamplerBorderColorInt(RADsampler sampler, const RADuint *borderColor)\r
1650 {\r
1651         rad::Sampler *radSampler = reinterpret_cast<rad::Sampler*>(sampler);\r
1652         radSampler->borderColorInt[0] = borderColor[0];\r
1653         radSampler->borderColorInt[1] = borderColor[1];\r
1654         radSampler->borderColorInt[2] = borderColor[2];\r
1655         radSampler->borderColorInt[3] = borderColor[3];\r
1656 }\r
1657 \r
1658 RADcolorState RADAPIENTRY radCreateColorState(RADdevice device)\r
1659 {\r
1660         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1661         rad::ColorState *colorState = new rad::ColorState(radDevice);\r
1662         return reinterpret_cast<RADcolorState>(colorState);\r
1663 }\r
1664 \r
1665 void RADAPIENTRY radReferenceColorState(RADcolorState color)\r
1666 {\r
1667         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1668         colorState->reference();\r
1669 }\r
1670 \r
1671 void RADAPIENTRY radReleaseColorState(RADcolorState color)\r
1672 {\r
1673         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1674         colorState->release();\r
1675 }\r
1676 \r
1677 void RADAPIENTRY radColorDefault(RADcolorState color)\r
1678 {\r
1679         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1680         colorState->default();\r
1681 }\r
1682 \r
1683 void RADAPIENTRY radColorBlendEnable(RADcolorState color, RADuint index, RADboolean enable)\r
1684 {\r
1685         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1686         colorState->blend[index].enable = enable;\r
1687 }\r
1688 \r
1689 void RADAPIENTRY radColorBlendFunc(RADcolorState color, RADuint index, RADblendFunc srcFunc, RADblendFunc dstFunc, RADblendFunc srcFuncAlpha, RADblendFunc dstFuncAlpha)\r
1690 {\r
1691         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1692         colorState->blend[index].srcFunc = srcFunc;\r
1693         colorState->blend[index].dstFunc = dstFunc;\r
1694         colorState->blend[index].srcFuncAlpha = srcFuncAlpha;\r
1695         colorState->blend[index].dstFuncAlpha = dstFuncAlpha;\r
1696 }\r
1697 \r
1698 void RADAPIENTRY radColorBlendEquation(RADcolorState color, RADuint index, RADblendEquation modeRGB, RADblendEquation modeAlpha)\r
1699 {\r
1700         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1701         colorState->blend[index].modeRGB = modeRGB;\r
1702         colorState->blend[index].modeAlpha = modeAlpha;\r
1703 }\r
1704 \r
1705 void RADAPIENTRY radColorMask(RADcolorState color, RADuint index, RADboolean r, RADboolean g, RADboolean b, RADboolean a)\r
1706 {\r
1707         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1708         colorState->blend[index].maskRGBA[0] = r;\r
1709         colorState->blend[index].maskRGBA[1] = g;\r
1710         colorState->blend[index].maskRGBA[2] = b;\r
1711         colorState->blend[index].maskRGBA[3] = a;\r
1712 }\r
1713 \r
1714 void RADAPIENTRY radColorNumTargets(RADcolorState color, RADuint numTargets)\r
1715 {\r
1716         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1717         colorState->numTargets = numTargets;\r
1718 }\r
1719 \r
1720 void RADAPIENTRY radColorLogicOpEnable(RADcolorState color, RADboolean enable)\r
1721 {\r
1722         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1723         colorState->logicOpEnable = enable;\r
1724 }\r
1725 \r
1726 void RADAPIENTRY radColorLogicOp(RADcolorState color, RADlogicOp logicOp)\r
1727 {\r
1728         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1729         colorState->logicOp = logicOp;\r
1730 }\r
1731 \r
1732 void RADAPIENTRY radColorAlphaToCoverageEnable(RADcolorState color, RADboolean enable)\r
1733 {\r
1734         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1735         colorState->alphaToCoverageEnable = enable;\r
1736 }\r
1737 \r
1738 void RADAPIENTRY radColorBlendColor(RADcolorState color, const RADfloat *blendColor)\r
1739 {\r
1740         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
1741         colorState->blendColor[0] = blendColor[0];\r
1742         colorState->blendColor[1] = blendColor[1];\r
1743         colorState->blendColor[2] = blendColor[2];\r
1744         colorState->blendColor[3] = blendColor[3];\r
1745 }\r
1746 \r
1747 void RADAPIENTRY radColorDynamic(RADcolorState color, RADcolorDynamic dynamic, RADboolean enable) {UNIMPLEMENTED();}\r
1748 \r
1749 RADrasterState RADAPIENTRY radCreateRasterState(RADdevice device)\r
1750 {\r
1751         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1752         rad::RasterState *rasterState = new rad::RasterState(radDevice);\r
1753         return reinterpret_cast<RADrasterState>(rasterState);\r
1754 }\r
1755 \r
1756 void RADAPIENTRY radReferenceRasterState(RADrasterState raster)\r
1757 {\r
1758         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1759         rasterState->reference();\r
1760 }\r
1761 \r
1762 void RADAPIENTRY radReleaseRasterState(RADrasterState raster)\r
1763 {\r
1764         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1765         rasterState->release();\r
1766 }\r
1767 \r
1768 void RADAPIENTRY radRasterDefault(RADrasterState raster)\r
1769 {\r
1770         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1771         rasterState->default();\r
1772 }\r
1773 \r
1774 void RADAPIENTRY radRasterPointSize(RADrasterState raster, RADfloat pointSize)\r
1775 {\r
1776         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1777         rasterState->pointSize = pointSize;\r
1778 }\r
1779 \r
1780 void RADAPIENTRY radRasterLineWidth(RADrasterState raster, RADfloat lineWidth)\r
1781 {\r
1782         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1783         rasterState->lineWidth = lineWidth;\r
1784 }\r
1785 \r
1786 void RADAPIENTRY radRasterCullFace(RADrasterState raster, RADfaceBitfield face)\r
1787 {\r
1788         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1789         rasterState->cullFace = face;\r
1790 }\r
1791 \r
1792 void RADAPIENTRY radRasterFrontFace(RADrasterState raster, RADfrontFace face)\r
1793 {\r
1794         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1795         rasterState->frontFace = face;\r
1796 }\r
1797 \r
1798 void RADAPIENTRY radRasterPolygonMode(RADrasterState raster, RADpolygonMode polygonMode)\r
1799 {\r
1800         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1801         rasterState->polygonMode = polygonMode;\r
1802 }\r
1803 \r
1804 void RADAPIENTRY radRasterPolygonOffsetClamp(RADrasterState raster, RADfloat factor, RADfloat units, RADfloat clamp)\r
1805 {\r
1806         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1807         rasterState->offsetFactor = factor;\r
1808         rasterState->offsetUnits = units;\r
1809         rasterState->offsetClamp = clamp;\r
1810 }\r
1811 \r
1812 void RADAPIENTRY radRasterPolygonOffsetEnables(RADrasterState raster, RADpolygonOffsetEnables enables)\r
1813 {\r
1814         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1815         rasterState->polygonOffsetEnables = enables;\r
1816 }\r
1817 \r
1818 void RADAPIENTRY radRasterDiscardEnable(RADrasterState raster, RADboolean enable)\r
1819 {\r
1820         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1821         rasterState->discardEnable = enable;\r
1822 }\r
1823 \r
1824 void RADAPIENTRY radRasterMultisampleEnable(RADrasterState raster, RADboolean enable)\r
1825 {\r
1826         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1827         rasterState->multisampleEnable = enable;\r
1828 }\r
1829 \r
1830 void RADAPIENTRY radRasterSamples(RADrasterState raster, RADuint samples)\r
1831 {\r
1832         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1833         rasterState->samples = samples;\r
1834 }\r
1835 \r
1836 void RADAPIENTRY radRasterSampleMask(RADrasterState raster, RADuint mask)\r
1837 {\r
1838         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
1839         rasterState->sampleMask = mask;\r
1840 }\r
1841 \r
1842 void RADAPIENTRY radRasterDynamic(RADrasterState raster, RADrasterDynamic dynamic, RADboolean enable)\r
1843 {\r
1844         UNIMPLEMENTED();\r
1845 }\r
1846 \r
1847 RADdepthStencilState RADAPIENTRY radCreateDepthStencilState(RADdevice device)\r
1848 {\r
1849         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1850         rad::DepthStencilState *depthStencilState = new rad::DepthStencilState(radDevice);\r
1851         return reinterpret_cast<RADdepthStencilState>(depthStencilState);\r
1852 }\r
1853 \r
1854 void RADAPIENTRY radReferenceDepthStencilState(RADdepthStencilState depthStencil)\r
1855 {\r
1856         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1857         depthStencilState->reference();\r
1858 }\r
1859 \r
1860 void RADAPIENTRY radReleaseDepthStencilState(RADdepthStencilState depthStencil)\r
1861 {\r
1862         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1863         depthStencilState->release();\r
1864 }\r
1865 \r
1866 void RADAPIENTRY radDepthStencilDefault(RADdepthStencilState depthStencil)\r
1867 {\r
1868         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1869         depthStencilState->default();\r
1870 }\r
1871 \r
1872 void RADAPIENTRY radDepthStencilDepthTestEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
1873 {\r
1874         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1875         depthStencilState->depthTestEnable = enable;\r
1876 }\r
1877 \r
1878 void RADAPIENTRY radDepthStencilDepthWriteEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
1879 {\r
1880         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1881         depthStencilState->depthWriteEnable = enable;\r
1882 }\r
1883 \r
1884 void RADAPIENTRY radDepthStencilDepthFunc(RADdepthStencilState depthStencil, RADdepthFunc func)\r
1885 {\r
1886         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1887         depthStencilState->depthFunc = func;\r
1888 }\r
1889 \r
1890 void RADAPIENTRY radDepthStencilStencilTestEnable(RADdepthStencilState depthStencil, RADboolean enable)\r
1891 {\r
1892         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1893         depthStencilState->stencilTestEnable = enable;\r
1894 }\r
1895 \r
1896 void RADAPIENTRY radDepthStencilStencilFunc(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilFunc func, RADint ref, RADuint mask)\r
1897 {\r
1898         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1899 \r
1900         if(faces & RAD_FACE_FRONT)\r
1901         {\r
1902                 depthStencilState->stencilFuncFront = func;\r
1903                 depthStencilState->stencilRefFront = ref;\r
1904                 depthStencilState->stencilMaskFront = mask;\r
1905         }\r
1906 \r
1907         if(faces & RAD_FACE_BACK)\r
1908         {\r
1909                 depthStencilState->stencilFuncBack = func;\r
1910                 depthStencilState->stencilRefBack = ref;\r
1911                 depthStencilState->stencilMaskBack = mask;\r
1912         }\r
1913 }\r
1914 \r
1915 void RADAPIENTRY radDepthStencilStencilOp(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADstencilOp fail, RADstencilOp depthFail, RADstencilOp depthPass)\r
1916 {\r
1917         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1918         \r
1919         if(faces & RAD_FACE_FRONT)\r
1920         {\r
1921                 depthStencilState->stencilFailOpFront = fail;\r
1922                 depthStencilState->depthFailOpFront = depthFail;\r
1923                 depthStencilState->depthPassOpFront = depthPass;\r
1924         }\r
1925 \r
1926         if(faces & RAD_FACE_BACK)\r
1927         {\r
1928                 depthStencilState->stencilFailOpBack = fail;\r
1929                 depthStencilState->depthFailOpBack = depthFail;\r
1930                 depthStencilState->depthPassOpBack = depthPass;\r
1931         }\r
1932 }\r
1933 \r
1934 void RADAPIENTRY radDepthStencilStencilMask(RADdepthStencilState depthStencil, RADfaceBitfield faces, RADuint mask)\r
1935 {\r
1936         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
1937         \r
1938         if(faces & RAD_FACE_FRONT)\r
1939         {\r
1940                 depthStencilState->stencilMaskFront = mask;\r
1941                 \r
1942         }\r
1943 \r
1944         if(faces & RAD_FACE_BACK)\r
1945         {\r
1946                 depthStencilState->stencilMaskBack = mask;\r
1947         }\r
1948 }\r
1949 \r
1950 void RADAPIENTRY radDepthStencilDynamic(RADdepthStencilState depthStencil, RADdepthStencilDynamic dynamic, RADboolean enable)\r
1951 {\r
1952         UNIMPLEMENTED();\r
1953 }\r
1954 \r
1955 RADvertexState RADAPIENTRY radCreateVertexState(RADdevice device)\r
1956 {\r
1957         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
1958         rad::VertexState *vertexState = new rad::VertexState(radDevice);\r
1959         return reinterpret_cast<RADvertexState>(vertexState);\r
1960 }\r
1961 \r
1962 void RADAPIENTRY radReferenceVertexState(RADvertexState vertex)\r
1963 {\r
1964         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
1965         vertexState->reference();\r
1966 }\r
1967 \r
1968 void RADAPIENTRY radReleaseVertexState(RADvertexState vertex)\r
1969 {\r
1970         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
1971         vertexState->release();\r
1972 }\r
1973 \r
1974 void RADAPIENTRY radVertexDefault(RADvertexState vertex) {UNIMPLEMENTED();}\r
1975 \r
1976 void RADAPIENTRY radVertexAttribFormat(RADvertexState vertex, RADint attribIndex, RADint numComponents, RADint bytesPerComponent, RADattribType type, RADuint relativeOffset)\r
1977 {\r
1978         ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
1979         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
1980         vertexState->attrib[attribIndex].numComponents = numComponents;\r
1981         vertexState->attrib[attribIndex].bytesPerComponent = bytesPerComponent;\r
1982         vertexState->attrib[attribIndex].type = type;\r
1983         vertexState->attrib[attribIndex].relativeOffset = relativeOffset;\r
1984 }\r
1985 \r
1986 void RADAPIENTRY radVertexAttribBinding(RADvertexState vertex, RADint attribIndex, RADint bindingIndex)\r
1987 {\r
1988         ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
1989         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
1990         vertexState->attrib[attribIndex].bindingIndex = bindingIndex;\r
1991 }\r
1992 \r
1993 void RADAPIENTRY radVertexBindingGroup(RADvertexState vertex, RADint bindingIndex, RADint group, RADint index)\r
1994 {\r
1995         ASSERT(bindingIndex >= 0 && bindingIndex < GL_MAX_VERTEX_ATTRIBS);\r
1996         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
1997         vertexState->binding[bindingIndex].group = group;\r
1998         vertexState->binding[bindingIndex].index = index;\r
1999 }\r
2000 \r
2001 void RADAPIENTRY radVertexAttribEnable(RADvertexState vertex, RADint attribIndex, RADboolean enable)\r
2002 {\r
2003         ASSERT(attribIndex >= 0 && attribIndex < GL_MAX_VERTEX_ATTRIBS);\r
2004         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
2005         vertexState->attrib[attribIndex].bindingIndex = enable;\r
2006 }\r
2007 \r
2008 void RADAPIENTRY radVertexBindingStride(RADvertexState vertex, RADint bindingIndex, RADuint stride)\r
2009 {\r
2010         ASSERT(bindingIndex >= 0 && bindingIndex < GL_MAX_VERTEX_ATTRIBS);\r
2011         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
2012         vertexState->binding[bindingIndex].stride = stride;\r
2013 }\r
2014 \r
2015 RADrtFormatState RADAPIENTRY radCreateRtFormatState(RADdevice device)\r
2016 {\r
2017         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
2018         rad::FormatState *formatState = new rad::FormatState(radDevice);\r
2019         return reinterpret_cast<RADrtFormatState>(formatState);\r
2020 }\r
2021 \r
2022 void RADAPIENTRY radReferenceRtFormatState(RADrtFormatState rtFormat)\r
2023 {\r
2024         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2025         formatState->reference();\r
2026 }\r
2027 \r
2028 void RADAPIENTRY radReleaseRtFormatState(RADrtFormatState rtFormat)\r
2029 {\r
2030         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2031         formatState->release();\r
2032 }\r
2033 \r
2034 void RADAPIENTRY radRtFormatDefault(RADrtFormatState rtFormat)\r
2035 {\r
2036         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2037         formatState->default();\r
2038 }\r
2039 \r
2040 void RADAPIENTRY radRtFormatColorFormat(RADrtFormatState rtFormat, RADuint index, RADinternalFormat format)\r
2041 {\r
2042         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2043         formatState->colorFormat[index] = format;\r
2044 }\r
2045 \r
2046 void RADAPIENTRY radRtFormatDepthFormat(RADrtFormatState rtFormat, RADinternalFormat format)\r
2047 {\r
2048         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2049         formatState->depthFormat = format;\r
2050 }\r
2051 \r
2052 void RADAPIENTRY radRtFormatStencilFormat(RADrtFormatState rtFormat, RADinternalFormat format)\r
2053 {\r
2054         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2055         formatState->stencilFormat = format;\r
2056 }\r
2057 \r
2058 void RADAPIENTRY radRtFormatColorSamples(RADrtFormatState rtFormat, RADuint samples)\r
2059 {\r
2060         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2061         formatState->colorSamples = samples;\r
2062 }\r
2063 \r
2064 void RADAPIENTRY radRtFormatDepthStencilSamples(RADrtFormatState rtFormat, RADuint samples)\r
2065 {\r
2066         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2067         formatState->depthStencilSamples = samples;\r
2068 }\r
2069 \r
2070 RADpipeline RADAPIENTRY radCreatePipeline(RADdevice device, RADpipelineType pipelineType)\r
2071 {\r
2072         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
2073         rad::Pipeline *pipeline = new rad::Pipeline(radDevice);\r
2074         return reinterpret_cast<RADpipeline>(pipeline);\r
2075 }\r
2076 \r
2077 void RADAPIENTRY radReferencePipeline(RADpipeline pipeline)\r
2078 {\r
2079         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2080         radPipeline->reference();\r
2081 }\r
2082 \r
2083 void RADAPIENTRY radReleasePipeline(RADpipeline pipeline)\r
2084 {\r
2085         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2086         radPipeline->release();\r
2087 }\r
2088 \r
2089 void RADAPIENTRY radPipelineProgramStages(RADpipeline pipeline, RADbitfield stages, RADprogram program)\r
2090 {\r
2091         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2092         rad::Program *radProgram = reinterpret_cast<rad::Program*>(program);\r
2093 \r
2094         if(stages & RAD_VERTEX_SHADER_BIT)\r
2095         {\r
2096                 ASSERT(!radPipeline->vertexProgram);\r
2097                 radProgram->reference();   // FIXME: here or at compile?\r
2098                 radPipeline->vertexProgram = radProgram;\r
2099         }\r
2100 \r
2101         if(stages & RAD_FRAGMENT_SHADER_BIT)\r
2102         {\r
2103                 ASSERT(!radPipeline->fragmentProgram);\r
2104                 radProgram->reference();   // FIXME: here or at compile?\r
2105                 radPipeline->fragmentProgram = radProgram;\r
2106         }\r
2107 }\r
2108 \r
2109 void RADAPIENTRY radPipelineVertexState(RADpipeline pipeline, RADvertexState vertex)\r
2110 {\r
2111         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2112         rad::VertexState *vertexState = reinterpret_cast<rad::VertexState*>(vertex);\r
2113         ASSERT(!radPipeline->vertexState);\r
2114         vertexState->reference();   // FIXME: here or at compile?\r
2115         radPipeline->vertexState = vertexState;\r
2116 }\r
2117 \r
2118 void RADAPIENTRY radPipelineColorState(RADpipeline pipeline, RADcolorState color)\r
2119 {\r
2120         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2121         rad::ColorState *colorState = reinterpret_cast<rad::ColorState*>(color);\r
2122         ASSERT(!radPipeline->colorState);\r
2123         colorState->reference();   // FIXME: here or at compile?\r
2124         radPipeline->colorState = colorState;\r
2125 }\r
2126 \r
2127 void RADAPIENTRY radPipelineRasterState(RADpipeline pipeline, RADrasterState raster)\r
2128 {\r
2129         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2130         rad::RasterState *rasterState = reinterpret_cast<rad::RasterState*>(raster);\r
2131         ASSERT(!radPipeline->rasterState);\r
2132         rasterState->reference();   // FIXME: here or at compile?\r
2133         radPipeline->rasterState = rasterState;\r
2134 }\r
2135 \r
2136 void RADAPIENTRY radPipelineDepthStencilState(RADpipeline pipeline, RADdepthStencilState depthStencil)\r
2137 {\r
2138         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2139         rad::DepthStencilState *depthStencilState = reinterpret_cast<rad::DepthStencilState*>(depthStencil);\r
2140         ASSERT(!radPipeline->depthStencilState);\r
2141         depthStencilState->reference();   // FIXME: here or at compile?\r
2142         radPipeline->depthStencilState = depthStencilState;\r
2143 }\r
2144 \r
2145 void RADAPIENTRY radPipelineRtFormatState(RADpipeline pipeline, RADrtFormatState rtFormat)\r
2146 {\r
2147         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2148         rad::FormatState *formatState = reinterpret_cast<rad::FormatState*>(rtFormat);\r
2149         ASSERT(!radPipeline->formatState);\r
2150         formatState->reference();   // FIXME: here or at compile?\r
2151         radPipeline->formatState = formatState;\r
2152 }\r
2153 \r
2154 void RADAPIENTRY radPipelinePrimitiveType(RADpipeline pipeline, RADprimitiveType mode)\r
2155 {\r
2156         rad::Pipeline *radPipeline = reinterpret_cast<rad::Pipeline*>(pipeline);\r
2157         radPipeline->primitiveType = mode;\r
2158 }\r
2159 \r
2160 void RADAPIENTRY radCompilePipeline(RADpipeline pipeline)\r
2161 {\r
2162         // FIXME: Reference state objects here or when set?\r
2163         return;\r
2164 }\r
2165 \r
2166 RADpipelineHandle RADAPIENTRY radGetPipelineHandle(RADpipeline pipeline)\r
2167 {\r
2168         return reinterpret_cast<RADpipelineHandle>(pipeline);\r
2169 }\r
2170 \r
2171 RADcommandBuffer RADAPIENTRY radCreateCommandBuffer(RADdevice device, RADqueueType queueType)\r
2172 {\r
2173         return 0;\r
2174 }\r
2175 \r
2176 void RADAPIENTRY radReferenceCommandBuffer(RADcommandBuffer cmdBuf) {UNIMPLEMENTED();}\r
2177 \r
2178 void RADAPIENTRY radReleaseCommandBuffer(RADcommandBuffer cmdBuf)\r
2179 {\r
2180         return;\r
2181 }\r
2182 \r
2183 void RADAPIENTRY radCmdBindPipeline(RADcommandBuffer cmdBuf, RADpipelineType pipelineType, RADpipelineHandle pipelineHandle)\r
2184 {\r
2185         return;\r
2186 }\r
2187 \r
2188 void RADAPIENTRY radCmdBindGroup(RADcommandBuffer cmdBuf, RADbitfield stages, RADuint group, RADuint count, RADbindGroupHandle groupHandle, RADuint offset)\r
2189 {\r
2190         \r
2191 }\r
2192 \r
2193 void RADAPIENTRY radCmdDrawArrays(RADcommandBuffer cmdBuf, RADprimitiveType mode, RADint first, RADsizei count) {UNIMPLEMENTED();}\r
2194 \r
2195 void RADAPIENTRY radCmdDrawElements(RADcommandBuffer cmdBuf, RADprimitiveType mode, RADindexType type, RADsizei count, RADindexHandle indexHandle, RADuint offset)\r
2196 {\r
2197         return;\r
2198 }\r
2199 \r
2200 RADboolean RADAPIENTRY radCompileCommandBuffer(RADcommandBuffer cmdBuf)\r
2201 {\r
2202         return false;\r
2203 }\r
2204 \r
2205 RADcommandHandle RADAPIENTRY radGetCommandHandle(RADcommandBuffer cmdBuf)\r
2206 {\r
2207         return 0;\r
2208 }\r
2209 \r
2210 void RADAPIENTRY radCmdStencilValueMask(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
2211 void RADAPIENTRY radCmdStencilMask(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADuint mask) {UNIMPLEMENTED();}\r
2212 void RADAPIENTRY radCmdStencilRef(RADcommandBuffer cmdBuf, RADfaceBitfield faces, RADint ref) {UNIMPLEMENTED();}\r
2213 void RADAPIENTRY radCmdBlendColor(RADcommandBuffer cmdBuf, const RADfloat *blendColor) {UNIMPLEMENTED();}\r
2214 void RADAPIENTRY radCmdPointSize(RADcommandBuffer cmdBuf, RADfloat pointSize) {UNIMPLEMENTED();}\r
2215 void RADAPIENTRY radCmdLineWidth(RADcommandBuffer cmdBuf, RADfloat lineWidth) {UNIMPLEMENTED();}\r
2216 void RADAPIENTRY radCmdPolygonOffsetClamp(RADcommandBuffer cmdBuf, RADfloat factor, RADfloat units, RADfloat clamp) {UNIMPLEMENTED();}\r
2217 void RADAPIENTRY radCmdSampleMask(RADcommandBuffer cmdBuf, RADuint mask) {UNIMPLEMENTED();}\r
2218 \r
2219 RADpass RADAPIENTRY radCreatePass(RADdevice device)\r
2220 {\r
2221         rad::Device *radDevice = reinterpret_cast<rad::Device*>(device);\r
2222         rad::Pass *pass = new rad::Pass(radDevice);\r
2223         return reinterpret_cast<RADpass>(pass);\r
2224 }\r
2225 \r
2226 void RADAPIENTRY radReferencePass(RADpass pass)\r
2227 {\r
2228         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
2229         radPass->reference();\r
2230 }\r
2231 \r
2232 void RADAPIENTRY radReleasePass(RADpass pass)\r
2233 {\r
2234         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
2235         radPass->release();\r
2236 }\r
2237 \r
2238 void RADAPIENTRY radPassDefault(RADpass pass)\r
2239 {\r
2240         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
2241         radPass->default();\r
2242 }\r
2243 \r
2244 void RADAPIENTRY radCompilePass(RADpass pass)\r
2245 {\r
2246         return;\r
2247 }\r
2248 \r
2249 void RADAPIENTRY radPassRenderTargets(RADpass pass, RADuint numColors, const RADrenderTargetHandle *colors, RADrenderTargetHandle depth, RADrenderTargetHandle stencil)\r
2250 {\r
2251         rad::Pass *radPass = reinterpret_cast<rad::Pass*>(pass);\r
2252         radPass->numColors = numColors;\r
2253         for(unsigned int i = 0; i < numColors; i++)\r
2254         {\r
2255                 ASSERT(colors[i]);\r
2256                 es2::Image *colorTarget = reinterpret_cast<es2::Image*>(colors[i]);\r
2257                 colorTarget->addRef();   // FIXME: here or at compile?\r
2258                 radPass->colorTarget[i] = colorTarget;\r
2259         }\r
2260 \r
2261         if(depth)\r
2262         {\r
2263                 es2::Image *depthTarget = reinterpret_cast<es2::Image*>(depth);\r
2264                 depthTarget->addRef();   // FIXME: here or at compile?\r
2265                 radPass->depthTarget = depthTarget;\r
2266         }\r
2267 \r
2268         if(stencil)\r
2269         {\r
2270                 es2::Image *stencilTarget = reinterpret_cast<es2::Image*>(stencil);\r
2271                 stencilTarget->addRef();   // FIXME: here or at compile?\r
2272                 radPass->stencilTarget = stencilTarget;\r
2273         }\r
2274 }\r
2275 \r
2276 void RADAPIENTRY radPassPreserveEnable(RADpass pass, RADrtAttachment attachment, RADboolean enable) {UNIMPLEMENTED();}\r
2277 void RADAPIENTRY radPassDiscard(RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
2278 \r
2279 void RADAPIENTRY radPassResolve(RADpass pass, RADrtAttachment attachment, RADtexture texture)\r
2280 {\r
2281         return;\r
2282 }\r
2283 \r
2284 void RADAPIENTRY radPassStore(RADpass pass, RADuint numTextures, const RADtexture *textures, const RADoffset2D *offsets) {UNIMPLEMENTED();}\r
2285 void RADAPIENTRY radPassClip(RADpass pass, const RADrect2D *rect) {UNIMPLEMENTED();}\r
2286 void RADAPIENTRY radPassDependencies(RADpass pass, RADuint numPasses, const RADpass *otherPasses, const RADbitfield *srcMask, const RADbitfield *dstMask, const RADbitfield *flushMask, const RADbitfield *invalidateMask) {UNIMPLEMENTED();}\r
2287 void RADAPIENTRY radPassTilingBoundary(RADpass pass, RADboolean boundary) {UNIMPLEMENTED();}\r
2288 void RADAPIENTRY radPassTileFilterWidth(RADpass pass, RADuint filterWidth, RADuint filterHeight) {UNIMPLEMENTED();}\r
2289 void RADAPIENTRY radPassTileFootprint(RADpass pass, RADuint bytesPerPixel, RADuint maxFilterWidth, RADuint maxFilterHeight) {UNIMPLEMENTED();}\r
2290 \r
2291 RADsync RADAPIENTRY radCreateSync(RADdevice device)\r
2292 {\r
2293         return 0;\r
2294 }\r
2295 \r
2296 void RADAPIENTRY radReferenceSync(RADsync sync) {UNIMPLEMENTED();}\r
2297 \r
2298 void RADAPIENTRY radReleaseSync(RADsync sync)\r
2299 {\r
2300         return;\r
2301 }\r
2302 \r
2303 void RADAPIENTRY radQueueFenceSync(RADqueue queue, RADsync sync, RADsyncCondition condition, RADbitfield flags)\r
2304 {\r
2305         return;\r
2306 }\r
2307 \r
2308 RADwaitSyncResult RADAPIENTRY radWaitSync(RADsync sync, RADuint64 timeout) {UNIMPLEMENTED(); return RAD_WAIT_SYNC_FAILED;}\r
2309 \r
2310 RADboolean RADAPIENTRY radQueueWaitSync(RADqueue queue, RADsync sync)\r
2311 {\r
2312         return 0;\r
2313 }\r
2314 \r
2315 RADPROC RADAPIENTRY radGetProcAddress(const RADchar *procname)\r
2316 {\r
2317         struct Extension\r
2318     {\r
2319         const char *name;\r
2320         RADPROC address;\r
2321     };\r
2322 \r
2323     static const Extension glExtensions[] =\r
2324     {\r
2325         #define EXTENSION(name) {#name, (RADPROC)name}\r
2326                 \r
2327                 EXTENSION(radGetProcAddress),\r
2328                 EXTENSION(radCreateDevice),\r
2329                 EXTENSION(radReferenceDevice),\r
2330                 EXTENSION(radReleaseDevice),\r
2331                 EXTENSION(radGetTokenHeader),\r
2332                 EXTENSION(radCreateQueue),\r
2333                 EXTENSION(radReferenceQueue),\r
2334                 EXTENSION(radReleaseQueue),\r
2335                 EXTENSION(radQueueTagBuffer),\r
2336                 EXTENSION(radQueueTagTexture),\r
2337                 EXTENSION(radQueueSubmitCommands),\r
2338                 EXTENSION(radFlushQueue),\r
2339                 EXTENSION(radFinishQueue),\r
2340                 EXTENSION(radQueueViewport),\r
2341                 EXTENSION(radQueueScissor),\r
2342                 EXTENSION(radQueueCopyBufferToImage),\r
2343                 EXTENSION(radQueueCopyImageToBuffer),\r
2344                 EXTENSION(radQueueCopyBuffer),\r
2345                 EXTENSION(radQueueClearColor),\r
2346                 EXTENSION(radQueueClearDepth),\r
2347                 EXTENSION(radQueueClearStencil),\r
2348                 EXTENSION(radQueuePresent),\r
2349                 EXTENSION(radQueueDrawArrays),\r
2350                 EXTENSION(radQueueDrawElements),\r
2351                 EXTENSION(radQueueBindPipeline),\r
2352                 EXTENSION(radQueueBindGroup),\r
2353                 EXTENSION(radQueueBeginPass),\r
2354                 EXTENSION(radQueueEndPass),\r
2355                 EXTENSION(radQueueSubmitDynamic),\r
2356                 EXTENSION(radQueueStencilValueMask),\r
2357                 EXTENSION(radQueueStencilMask),\r
2358                 EXTENSION(radQueueStencilRef),\r
2359                 EXTENSION(radQueueBlendColor),\r
2360                 EXTENSION(radQueuePointSize),\r
2361                 EXTENSION(radQueueLineWidth),\r
2362                 EXTENSION(radQueuePolygonOffsetClamp),\r
2363                 EXTENSION(radQueueSampleMask),\r
2364                 EXTENSION(radCreateProgram),\r
2365                 EXTENSION(radReferenceProgram),\r
2366                 EXTENSION(radReleaseProgram),\r
2367                 EXTENSION(radProgramSource),\r
2368                 EXTENSION(radCreateBuffer),\r
2369                 EXTENSION(radReferenceBuffer),\r
2370                 EXTENSION(radReleaseBuffer),\r
2371                 EXTENSION(radBufferAccess),\r
2372                 EXTENSION(radBufferMapAccess),\r
2373                 EXTENSION(radBufferStorage),\r
2374                 EXTENSION(radMapBuffer),\r
2375                 EXTENSION(radGetVertexHandle),\r
2376                 EXTENSION(radGetIndexHandle),\r
2377                 EXTENSION(radGetUniformHandle),\r
2378                 EXTENSION(radGetBindGroupHandle),\r
2379                 EXTENSION(radCreateTexture),\r
2380                 EXTENSION(radReferenceTexture),\r
2381                 EXTENSION(radReleaseTexture),\r
2382                 EXTENSION(radTextureAccess),\r
2383                 EXTENSION(radTextureStorage),\r
2384                 EXTENSION(radGetTextureSamplerHandle),\r
2385                 EXTENSION(radGetTextureRenderTargetHandle),\r
2386                 EXTENSION(radCreateSampler),\r
2387                 EXTENSION(radReferenceSampler),\r
2388                 EXTENSION(radReleaseSampler),\r
2389                 EXTENSION(radSamplerDefault),\r
2390                 EXTENSION(radSamplerMinMagFilter),\r
2391                 EXTENSION(radSamplerWrapMode),\r
2392                 EXTENSION(radSamplerLodClamp),\r
2393                 EXTENSION(radSamplerLodBias),\r
2394                 EXTENSION(radSamplerCompare),\r
2395                 EXTENSION(radSamplerBorderColorFloat),\r
2396                 EXTENSION(radSamplerBorderColorInt),\r
2397                 EXTENSION(radCreateColorState),\r
2398                 EXTENSION(radReferenceColorState),\r
2399                 EXTENSION(radReleaseColorState),\r
2400                 EXTENSION(radColorDefault),\r
2401                 EXTENSION(radColorBlendEnable),\r
2402                 EXTENSION(radColorBlendFunc),\r
2403                 EXTENSION(radColorBlendEquation),\r
2404                 EXTENSION(radColorMask),\r
2405                 EXTENSION(radColorNumTargets),\r
2406                 EXTENSION(radColorLogicOpEnable),\r
2407                 EXTENSION(radColorLogicOp),\r
2408                 EXTENSION(radColorAlphaToCoverageEnable),\r
2409                 EXTENSION(radColorBlendColor),\r
2410                 EXTENSION(radColorDynamic),\r
2411                 EXTENSION(radCreateRasterState),\r
2412                 EXTENSION(radReferenceRasterState),\r
2413                 EXTENSION(radReleaseRasterState),\r
2414                 EXTENSION(radRasterDefault),\r
2415                 EXTENSION(radRasterPointSize),\r
2416                 EXTENSION(radRasterLineWidth),\r
2417                 EXTENSION(radRasterCullFace),\r
2418                 EXTENSION(radRasterFrontFace),\r
2419                 EXTENSION(radRasterPolygonMode),\r
2420                 EXTENSION(radRasterPolygonOffsetClamp),\r
2421                 EXTENSION(radRasterPolygonOffsetEnables),\r
2422                 EXTENSION(radRasterDiscardEnable),\r
2423                 EXTENSION(radRasterMultisampleEnable),\r
2424                 EXTENSION(radRasterSamples),\r
2425                 EXTENSION(radRasterSampleMask),\r
2426                 EXTENSION(radRasterDynamic),\r
2427                 EXTENSION(radCreateDepthStencilState),\r
2428                 EXTENSION(radReferenceDepthStencilState),\r
2429                 EXTENSION(radReleaseDepthStencilState),\r
2430                 EXTENSION(radDepthStencilDefault),\r
2431                 EXTENSION(radDepthStencilDepthTestEnable),\r
2432                 EXTENSION(radDepthStencilDepthWriteEnable),\r
2433                 EXTENSION(radDepthStencilDepthFunc),\r
2434                 EXTENSION(radDepthStencilStencilTestEnable),\r
2435                 EXTENSION(radDepthStencilStencilFunc),\r
2436                 EXTENSION(radDepthStencilStencilOp),\r
2437                 EXTENSION(radDepthStencilStencilMask),\r
2438                 EXTENSION(radDepthStencilDynamic),\r
2439                 EXTENSION(radCreateVertexState),\r
2440                 EXTENSION(radReferenceVertexState),\r
2441                 EXTENSION(radReleaseVertexState),\r
2442                 EXTENSION(radVertexDefault),\r
2443                 EXTENSION(radVertexAttribFormat),\r
2444                 EXTENSION(radVertexAttribBinding),\r
2445                 EXTENSION(radVertexBindingGroup),\r
2446                 EXTENSION(radVertexAttribEnable),\r
2447                 EXTENSION(radVertexBindingStride),\r
2448                 EXTENSION(radCreateRtFormatState),\r
2449                 EXTENSION(radReferenceRtFormatState),\r
2450                 EXTENSION(radReleaseRtFormatState),\r
2451                 EXTENSION(radRtFormatDefault),\r
2452                 EXTENSION(radRtFormatColorFormat),\r
2453                 EXTENSION(radRtFormatDepthFormat),\r
2454                 EXTENSION(radRtFormatStencilFormat),\r
2455                 EXTENSION(radRtFormatColorSamples),\r
2456                 EXTENSION(radRtFormatDepthStencilSamples),\r
2457                 EXTENSION(radCreatePipeline),\r
2458                 EXTENSION(radReferencePipeline),\r
2459                 EXTENSION(radReleasePipeline),\r
2460                 EXTENSION(radPipelineProgramStages),\r
2461                 EXTENSION(radPipelineVertexState),\r
2462                 EXTENSION(radPipelineColorState),\r
2463                 EXTENSION(radPipelineRasterState),\r
2464                 EXTENSION(radPipelineDepthStencilState),\r
2465                 EXTENSION(radPipelineRtFormatState),\r
2466                 EXTENSION(radPipelinePrimitiveType),\r
2467                 EXTENSION(radCompilePipeline),\r
2468                 EXTENSION(radGetPipelineHandle),\r
2469                 EXTENSION(radCreateCommandBuffer),\r
2470                 EXTENSION(radReferenceCommandBuffer),\r
2471                 EXTENSION(radReleaseCommandBuffer),\r
2472                 EXTENSION(radCmdBindPipeline),\r
2473                 EXTENSION(radCmdBindGroup),\r
2474                 EXTENSION(radCmdDrawArrays),\r
2475                 EXTENSION(radCmdDrawElements),\r
2476                 EXTENSION(radCompileCommandBuffer),\r
2477                 EXTENSION(radGetCommandHandle),\r
2478                 EXTENSION(radCmdStencilValueMask),\r
2479                 EXTENSION(radCmdStencilMask),\r
2480                 EXTENSION(radCmdStencilRef),\r
2481                 EXTENSION(radCmdBlendColor),\r
2482                 EXTENSION(radCmdPointSize),\r
2483                 EXTENSION(radCmdLineWidth),\r
2484                 EXTENSION(radCmdPolygonOffsetClamp),\r
2485                 EXTENSION(radCmdSampleMask),\r
2486                 EXTENSION(radCreatePass),\r
2487                 EXTENSION(radReferencePass),\r
2488                 EXTENSION(radReleasePass),\r
2489                 EXTENSION(radPassDefault),\r
2490                 EXTENSION(radCompilePass),\r
2491                 EXTENSION(radPassRenderTargets),\r
2492                 EXTENSION(radPassPreserveEnable),\r
2493                 EXTENSION(radPassDiscard),\r
2494                 EXTENSION(radPassResolve),\r
2495                 EXTENSION(radPassStore),\r
2496                 EXTENSION(radPassClip),\r
2497                 EXTENSION(radPassDependencies),\r
2498                 EXTENSION(radPassTilingBoundary),\r
2499                 EXTENSION(radPassTileFilterWidth),\r
2500                 EXTENSION(radPassTileFootprint),\r
2501                 EXTENSION(radCreateSync),\r
2502                 EXTENSION(radReferenceSync),\r
2503                 EXTENSION(radReleaseSync),\r
2504                 EXTENSION(radQueueFenceSync),\r
2505                 EXTENSION(radWaitSync),\r
2506                 EXTENSION(radQueueWaitSync),\r
2507 \r
2508                 #undef EXTENSION\r
2509     };\r
2510 \r
2511     for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)\r
2512     {\r
2513         if(strcmp(procname, glExtensions[ext].name) == 0)\r
2514         {\r
2515             return (RADPROC)glExtensions[ext].address;\r
2516         }\r
2517     }\r
2518 \r
2519     return NULL;\r
2520 }\r
2521 \r
2522 void GL_APIENTRY Register(const char *licenseKey)\r
2523 {\r
2524         RegisterLicenseKey(licenseKey);\r
2525 }\r
2526 \r
2527 }\r