开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
vertexprog.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：15k
源码类别：

OpenGL

开发平台：

Visual C++

vertexprog.cpp：源码内容
  1. // vertexprog.cpp
  2. //
  3. // Copyright (C) 2001 Chris Laurel <claurel@shatters.net>
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  10. #include <iostream>
  11. #include <fstream>
  12. #include <string>
  13. #include <celutil/util.h>
  14. #include "gl.h"
  15. #include "glext.h"
  16. #include "vertexprog.h"
  18. using namespace std;
  21. unsigned int vp::diffuse = 0;
  22. unsigned int vp::specular = 0;
  23. unsigned int vp::diffuseHaze = 0;
  24. unsigned int vp::diffuseBump = 0;
  25. unsigned int vp::diffuseBumpHaze = 0;
  26. unsigned int vp::shadowTexture = 0;
  27. unsigned int vp::multiShadow = 0;
  28. unsigned int vp::everything = 0;
  29. unsigned int vp::diffuseTexOffset = 0;
  30. unsigned int vp::ringIllum = 0;
  31. unsigned int vp::ringShadow = 0;
  32. unsigned int vp::cometTail = 0;
  33. unsigned int vp::nightLights = 0;
  34. unsigned int vp::glossMap = 0;
  35. unsigned int vp::perFragmentSpecular = 0;
  36. unsigned int vp::perFragmentSpecularAlpha = 0;
  37. unsigned int vp::diffuse_2light = 0;
  38. unsigned int vp::diffuseHaze_2light = 0;
  39. unsigned int vp::diffuseTexOffset_2light = 0;
  40. unsigned int vp::specular_2light = 0;
  41. unsigned int vp::nightLights_2light = 0;
  42. unsigned int vp::ellipticalGalaxy = 0;
  43. unsigned int vp::starDisc = 0;
  44. #ifdef HDR_COMPRESS
  45. unsigned int vp::diffuseBumpHDR = 0;
  46. unsigned int vp::diffuseBumpHazeHDR = 0;
  47. unsigned int vp::nightLightsHDR = 0;
  48. unsigned int vp::nightLights_2lightHDR = 0;
  49. #endif
  52. class VertexProcessorNV : public VertexProcessor
  53. {
  54.  public:
  55.     VertexProcessorNV();
  56.     virtual ~VertexProcessorNV();
  58.     virtual void enable();
  59.     virtual void disable();
  60.     virtual void use(unsigned int);
  61.     virtual void parameter(vp::Parameter, float, float, float, float);
  62.     virtual void parameter(vp::Parameter, const float*);
  64.     virtual void enableAttribArray(unsigned int);
  65.     virtual void disableAttribArray(unsigned int);
  66.     virtual void attribArray(unsigned int index,
  67.                              int size,
  68.                              GLenum type,
  69.                              unsigned int stride,
  70.                              const void* pointer);
  71. };
  73. class VertexProcessorARB : public VertexProcessor
  74. {
  75.  public:
  76.     VertexProcessorARB();
  77.     virtual ~VertexProcessorARB();
  79.     virtual void enable();
  80.     virtual void disable();
  81.     virtual void use(unsigned int);
  82.     virtual void parameter(vp::Parameter, float, float, float, float);
  83.     virtual void parameter(vp::Parameter, const float*);
  85.     virtual void enableAttribArray(unsigned int);
  86.     virtual void disableAttribArray(unsigned int);
  87.     virtual void attribArray(unsigned int index,
  88.                              int size,
  89.                              GLenum type,
  90.                              unsigned int stride,
  91.                              const void* pointer);
  92. };
  96. static string* ReadTextFromFile(const string& filename)
  97. {
  98.     ifstream textFile(filename.c_str(), ios::in);
  99.     if (!textFile.good())
  100.         return NULL;
  102.     string* s = new string();
  104.     char c;
  105.     while (textFile.get(c))
  106.         *s += c;
  108.     return s;
  109. }
  112. static bool LoadNvVertexProgram(const string& filename, unsigned int& id)
  113. {
  114.     cout << _("Loading NV vertex program: ") << filename << 'n';
  116.     string* source = ReadTextFromFile(filename);
  117.     if (source == NULL)
  118.     {
  119.         cout << _("Error loading NV vertex program: ") << filename << 'n';
  120.         return false;
  121.     }
  123.     glx::glGenProgramsNV(1, (GLuint*) &id);
  124.     glx::glLoadProgramNV(GL_VERTEX_PROGRAM_NV,
  125.                          id,
  126.                          source->length(),
  127.                          reinterpret_cast<const GLubyte*>(source->c_str()));
  129.     delete source;
  131.     GLenum err = glGetError();
  132.     if (err != GL_NO_ERROR)
  133.     {
  134.         GLint errPos = 0;
  135.         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV, &errPos);
  136.         cout << _("Error in vertex program ") << filename <<
  137.             " @ " << errPos << 'n';
  138.         return false;
  139.     }
  141.     return true;
  142. }
  145. static int findLineNumber(const string& s, int index)
  146. {
  147.     if (index >= (int)s.length())
  148.         return -1;
  150.     int lineno = 1;
  151.     for (int i = 0; i < index; i++)
  152.     {
  153.         if (s[i] == 'n')
  154.             lineno++;
  155.     }
  157.     return lineno;
  158. }
  161. static bool LoadARBVertexProgram(const string& filename, unsigned int& id)
  162. {
  163.     cout << _("Loading ARB vertex program: ") << filename << 'n';
  165.     string* source = ReadTextFromFile(filename);
  166.     if (source == NULL)
  167.     {
  168.         cout << _("Error loading ARB vertex program: ") << filename << 'n';
  169.         return false;
  170.     }
  172.     glx::glGenProgramsARB(1, (GLuint*) &id);
  173.     if (glGetError() != GL_NO_ERROR)
  174.     {
  175.         delete source;
  176.         return false;
  177.     }
  179.     glx::glBindProgramARB(GL_VERTEX_PROGRAM_ARB, id);
  180.     glx::glProgramStringARB(GL_VERTEX_PROGRAM_ARB,
  181.                             GL_PROGRAM_FORMAT_ASCII_ARB,
  182.                             source->length(),
  183.                             reinterpret_cast<const GLubyte*>(source->c_str()));
  185.     GLenum err = glGetError();
  186.     if (err != GL_NO_ERROR)
  187.     {
  188.         GLint errPos = 0;
  189.         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
  191.         const char* errMsg = (const char*) glGetString(GL_PROGRAM_ERROR_STRING_ARB);
  192.         if (errMsg == NULL)
  193.             errMsg = "Unknown error";
  194.         
  195.         cout << _("Error in vertex program ") << filename <<
  196.             _(", line ") << findLineNumber(*source, errPos) << ": " << errMsg << 'n';
  197.     }
  199.     delete source;
  201.     return err == GL_NO_ERROR;
  202. }
  205. // ARB path is preferred; NV vertex program path will eventually go away
  206. VertexProcessor* vp::initNV()
  207. {
  208.     cout << _("Initializing NV vertex programs . . .n");
  209.     if (!LoadNvVertexProgram("shaders/diffuse.vp", diffuse))
  210.         return NULL;
  211.     if (!LoadNvVertexProgram("shaders/specular.vp", specular))
  212.         return NULL;
  213.     if (!LoadNvVertexProgram("shaders/haze.vp", diffuseHaze))
  214.         return NULL;
  215.     if (!LoadNvVertexProgram("shaders/bumpdiffuse.vp", diffuseBump))
  216.         return NULL;
  217.     if (!LoadNvVertexProgram("shaders/bumphaze.vp", diffuseBumpHaze))
  218.         return NULL;
  219.     if (!LoadNvVertexProgram("shaders/shadowtex.vp", shadowTexture))
  220.         return NULL;
  221.     if (!LoadNvVertexProgram("shaders/diffuse_texoff.vp", diffuseTexOffset))
  222.         return NULL;
  223.     if (!LoadNvVertexProgram("shaders/rings.vp", ringIllum))
  224.         return NULL;
  225.     if (!LoadNvVertexProgram("shaders/ringshadow.vp", ringShadow))
  226.         return NULL;
  227.     if (!LoadNvVertexProgram("shaders/night.vp", nightLights))
  228.         return NULL;
  229.     // if (!LoadNvVertexProgram("shaders/comet.vp", cometTail))
  230.     //    return false;
  232.     // Two light shaders have only been written for the ARB vertex program path
  233.     // Fall back to the the one light versions.
  234.     diffuse_2light = diffuse;
  235.     diffuseHaze_2light = diffuseHaze;
  236.     diffuseTexOffset_2light = diffuseTexOffset;
  237.     specular_2light = specular;
  239.     everything = 0;
  240.     cout << _("All NV vertex programs loaded successfully.n");
  242.     glx::glTrackMatrixNV(GL_VERTEX_PROGRAM_NV,
  243.                          0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
  244.     glx::glTrackMatrixNV(GL_VERTEX_PROGRAM_NV,
  245.                          4, GL_MODELVIEW_PROJECTION_NV, GL_INVERSE_TRANSPOSE_NV);
  247.     return new VertexProcessorNV();
  248. }
  251. VertexProcessor* vp::initARB()
  252. {
  253.     cout << _("Initializing ARB vertex programs . . .n");
  254.     if (!LoadARBVertexProgram("shaders/diffuse_arb.vp", diffuse))
  255.         return NULL;
  256.     if (!LoadARBVertexProgram("shaders/specular_arb.vp", specular))
  257.         return NULL;
  258.     if (!LoadARBVertexProgram("shaders/haze_arb.vp", diffuseHaze))
  259.         return NULL;
  260.     if (!LoadARBVertexProgram("shaders/bumpdiffuse_arb.vp", diffuseBump))
  261.         return NULL;
  262.     if (!LoadARBVertexProgram("shaders/bumphaze_arb.vp", diffuseBumpHaze))
  263.         return NULL;
  264.     if (!LoadARBVertexProgram("shaders/shadowtex_arb.vp", shadowTexture))
  265.         return NULL;
  266.     if (!LoadARBVertexProgram("shaders/diffuse_texoff_arb.vp", diffuseTexOffset))
  267.         return NULL;
  268.     if (!LoadARBVertexProgram("shaders/rings_arb.vp", ringIllum))
  269.         return NULL;
  270.     if (!LoadARBVertexProgram("shaders/ringshadow_arb.vp", ringShadow))
  271.         return NULL;
  272.     if (!LoadARBVertexProgram("shaders/night_arb.vp", nightLights))
  273.         return NULL;
  274.     if (!LoadARBVertexProgram("shaders/glossmap_arb.vp", glossMap))
  275.         return NULL;
  276.     if (!LoadARBVertexProgram("shaders/diffuse2_arb.vp", diffuse_2light))
  277.         return NULL;
  278.     if (!LoadARBVertexProgram("shaders/haze2_arb.vp", diffuseHaze_2light))
  279.         return NULL;
  280.     if (!LoadARBVertexProgram("shaders/diffuse_texoff2_arb.vp", diffuseTexOffset_2light))
  281.         return NULL;
  282.     if (!LoadARBVertexProgram("shaders/specular2_arb.vp", specular_2light))
  283.         return NULL;
  284.     if (!LoadARBVertexProgram("shaders/night2_arb.vp", nightLights_2light))
  285.         return NULL;
  286.     if (!LoadARBVertexProgram("shaders/star_arb.vp", starDisc))
  287.         return NULL;
  288. #ifdef HDR_COMPRESS
  289.     if (!LoadARBVertexProgram("shaders/bumpdiffuse_arb_hdr.vp", diffuseBumpHDR))
  290.         return NULL;
  291.     if (!LoadARBVertexProgram("shaders/bumphaze_arb_hdr.vp", diffuseBumpHazeHDR))
  292.         return NULL;
  293.     if (!LoadARBVertexProgram("shaders/night_arb_hdr.vp", nightLightsHDR))
  294.         return NULL;
  295.     if (!LoadARBVertexProgram("shaders/night2_arb_hdr.vp", nightLights_2lightHDR))
  296.         return NULL;
  297. #endif
  299.     // Load vertex programs that are only required with fragment programs
  300.     if (ExtensionSupported("GL_NV_fragment_program") ||
  301.         ExtensionSupported("GL_ARB_fragment_program"))
  302.     {
  303.         if (!LoadARBVertexProgram("shaders/multishadow_arb.vp", multiShadow))
  304.             return NULL;
  305.         if (!LoadARBVertexProgram("shaders/texphong_arb.vp", perFragmentSpecular))
  306.             return NULL;
  307.         if (!LoadARBVertexProgram("shaders/texphong_alpha_arb.vp", perFragmentSpecularAlpha))
  308.             return NULL;
  309.     }
  311.     if (!LoadARBVertexProgram("shaders/ell_galaxy_arb.vp", ellipticalGalaxy))
  312.         return NULL;
  314.     cout << _("All ARB vertex programs loaded successfully.n");
  316.     return new VertexProcessorARB();
  317. }
  320. void vp::disable()
  321. {
  322.     glDisable(GL_VERTEX_PROGRAM_NV);
  323. }
  326. void vp::enable()
  327. {
  328.     glEnable(GL_VERTEX_PROGRAM_NV);
  329. }
  332. void vp::use(unsigned int prog)
  333. {
  334.     glx::glBindProgramNV(GL_VERTEX_PROGRAM_NV, prog);
  335. }
  338. void vp::parameter(unsigned int param, const Vec3f& v)
  339. {
  340.     glx::glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, param, v.x, v.y, v.z, 0.0f);
  341. }
  342.                             
  343. void vp::parameter(unsigned int param, const Point3f& p)
  344. {
  345.     glx::glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, param, p.x, p.y, p.z, 0.0f);
  346. }
  348. void vp::parameter(unsigned int param, const Color& c)
  349. {
  350.     glx::glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, param,
  351.                                 c.red(), c.green(), c.blue(), c.alpha());
  352. }
  354. void vp::parameter(unsigned int param, float x, float y, float z, float w)
  355. {
  356.     glx::glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, param, x, y, z, w);
  357. }
  361. void arbvp::parameter(unsigned int param, const Vec3f& v)
  362. {
  363.     glx::glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param,
  364.                                     v.x, v.y, v.z, 0.0f);
  365. }
  366.                             
  367. void arbvp::parameter(unsigned int param, const Point3f& p)
  368. {
  369.     glx::glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param,
  370.                                     p.x, p.y, p.z, 0.0f);
  371. }
  373. void arbvp::parameter(unsigned int param, const Color& c)
  374. {
  375.     glx::glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param,
  376.                                    c.red(), c.green(), c.blue(), c.alpha());
  377. }
  379. void arbvp::parameter(unsigned int param, float x, float y, float z, float w)
  380. {
  381.     glx::glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param, x, y, z, w);
  382. }
  384. void arbvp::parameter(unsigned int param, const float* fv)
  385. {
  386.     glx::glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, param, fv);
  387. }
  390. VertexProcessor::VertexProcessor()
  391. {
  392. }
  394. VertexProcessor::~VertexProcessor()
  395. {
  396. }
  398. void VertexProcessor::parameter(vp::Parameter param, const Vec3f& v)
  399. {
  400.     parameter(param, v.x, v.y, v.z, 0.0f);
  401. }
  402.                             
  403. void VertexProcessor::parameter(vp::Parameter param, const Point3f& p)
  404. {
  405.     parameter(param, p.x, p.y, p.z, 0.0f);
  406. }
  408. void VertexProcessor::parameter(vp::Parameter param, const Color& c)
  409. {
  410.     parameter(param, c.red(), c.green(), c.blue(), c.alpha());
  411. }
  415. // VertexProcessorNV implementation
  417. static unsigned int parameterMappings[] = 
  418. {
  419.     16, // LightDirection0
  420.     15, // EyePosition
  421.     20, // DiffuseColor0
  422.     34, // SpecularColor0
  423.     40, // SpecularExponent
  424.     32, // AmbientColor
  425.     33, // HazeColor
  426.     41, // TextureTranslation
  427.     90, // Constant0 - relevant for NV_vertex_program only
  428.      0, // Unused
  429.     41, // TexGen_S
  430.     42, // TexGen_T
  431.      0, // TexGen_S2
  432.      0, // TexGen_T2
  433.      0, // TexGen_S3
  434.      0, // TexGen_T3
  435.      0, // TexGen_S4
  436.      0, // TexGen_T4
  437.     50, // LightDirection1
  438.     51, // DiffuseColor1,
  439.     52, // SpecularColor1
  440. };
  442. VertexProcessorNV::VertexProcessorNV()
  443. {
  444. }
  446. VertexProcessorNV::~VertexProcessorNV()
  447. {
  448. }
  450. void VertexProcessorNV::enable()
  451. {
  452.     glEnable(GL_VERTEX_PROGRAM_NV);
  453. }
  455. void VertexProcessorNV::disable()
  456. {
  457.     glDisable(GL_VERTEX_PROGRAM_NV);
  458. }
  460. void VertexProcessorNV::use(unsigned int prog)
  461. {
  462.     glx::glBindProgramNV(GL_VERTEX_PROGRAM_NV, prog);
  463. }
  465. void VertexProcessorNV::parameter(vp::Parameter param,
  466.                                   float x, float y, float z, float w)
  467. {
  468.     glx::glProgramParameter4fNV(GL_VERTEX_PROGRAM_NV, 
  469.                                 parameterMappings[param], x, y, z, w);
  470. }
  472. void VertexProcessorNV::parameter(vp::Parameter param, const float* fv)
  473. {
  474.     glx::glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV,
  475.                                  parameterMappings[param], fv);
  476. }
  478. void VertexProcessorNV::enableAttribArray(unsigned int index)
  479. {
  480.     glEnableClientState(GL_VERTEX_ATTRIB_ARRAY0_NV + index);
  481. }
  483. void VertexProcessorNV::disableAttribArray(unsigned int index)
  484. {
  485.     glDisableClientState(GL_VERTEX_ATTRIB_ARRAY0_NV + index);
  486. }
  488. void VertexProcessorNV::attribArray(unsigned int index,
  489.                                      int size,
  490.                                      GLenum type,
  491.                                      unsigned int stride,
  492.                                      const void* ptr)
  493. {
  494.     glx::glVertexAttribPointerNV(index, size, type, stride, ptr);
  495. }
  499. // VertexProcessorARB implementation
  501. VertexProcessorARB::VertexProcessorARB()
  502. {
  503. }
  505. VertexProcessorARB::~VertexProcessorARB()
  506. {
  507. }
  509. void VertexProcessorARB::enable()
  510. {
  511.     glEnable(GL_VERTEX_PROGRAM_ARB);
  512. }
  514. void VertexProcessorARB::disable()
  515. {
  516.     glDisable(GL_VERTEX_PROGRAM_ARB);
  517. }
  519. void VertexProcessorARB::use(unsigned int prog)
  520. {
  521.     glx::glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog);
  522. }
  524. void VertexProcessorARB::parameter(vp::Parameter param,
  525.                                    float x, float y, float z, float w)
  526. {
  527.     glx::glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param, x, y, z, w);
  528. }
  530. void VertexProcessorARB::parameter(vp::Parameter param, const float* fv)
  531. {
  532.     glx::glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, param, fv);
  533. }
  535. void VertexProcessorARB::enableAttribArray(unsigned int index)
  536. {
  537.     glx::glEnableVertexAttribArrayARB(index);
  538. }
  540. void VertexProcessorARB::disableAttribArray(unsigned int index)
  541. {
  542.     glx::glDisableVertexAttribArrayARB(index);
  543. }
  545. void VertexProcessorARB::attribArray(unsigned int index,
  546.                                      int size,
  547.                                      GLenum type,
  548.                                      unsigned int stride,
  549.                                      const void* ptr)
  550. {
  551.     glx::glVertexAttribPointerARB(index, size, type, GL_FALSE, stride, ptr);
  552. }