2 //Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
5 //Redistribution and use in source and binary forms, with or without
6 //modification, are permitted provided that the following conditions
9 // Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
12 // Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following
14 // disclaimer in the documentation and/or other materials provided
15 // with the distribution.
17 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its
18 // contributors may be used to endorse or promote products derived
19 // from this software without specific prior written permission.
21 //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 //LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 //FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 //COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 //INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 //BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 //LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 //CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 //LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 //ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 //POSSIBILITY OF SUCH DAMAGE.
35 #ifndef _SHHANDLE_INCLUDED_
36 #define _SHHANDLE_INCLUDED_
39 // Machine independent part of the compiler private objects
40 // sent as ShHandle to the driver.
42 // This should not be included by driver code.
46 #include "../Public/ShaderLangExt.h"
59 // The base class used to back handles returned to the driver.
64 virtual ~TShHandleBase() { }
65 virtual TCompiler
* getAsCompiler() { return 0; }
66 virtual TLinker
* getAsLinker() { return 0; }
67 virtual Lf::TLinker
* getAsNewLinker() { return 0; }
68 virtual TUniformMap
* getAsUniformMap() { return 0; }
69 virtual Lf::TBindingList
* getAsBindingList() { return 0; }
70 virtual Lf::TLibrary
* getAsLibrary() { return 0; }
73 // The base class for the machine dependent linker to derive from
74 // for managing where uniforms live.
76 class TUniformMap
: public TShHandleBase
{
79 virtual ~TUniformMap() { }
80 virtual TUniformMap
* getAsUniformMap() { return this; }
81 virtual int getLocation(const char* name
) = 0;
82 virtual TInfoSink
& getInfoSink() { return infoSink
; }
89 // The base class for the machine dependent compiler to derive from
90 // for managing object code from the compile.
92 class TCompiler
: public TShHandleBase
{
94 TCompiler(EShLanguage l
, TInfoSink
& sink
) : infoSink(sink
) , language(l
), haveValidObjectCode(false) { }
95 virtual ~TCompiler() { }
96 EShLanguage
getLanguage() { return language
; }
97 virtual TInfoSink
& getInfoSink() { return infoSink
; }
99 virtual bool compile(TIntermNode
* root
) = 0;
101 virtual TCompiler
* getAsCompiler() { return this; }
102 virtual bool linkable() { return haveValidObjectCode
; }
106 EShLanguage language
;
107 bool haveValidObjectCode
;
111 // Link operations are base on a list of compile results...
113 typedef TVector
<TCompiler
*> TCompilerList
;
114 typedef TVector
<TShHandleBase
*> THandleList
;
117 // The base class for the machine dependent linker to derive from
118 // to manage the resulting executable.
121 class TLinker
: public TShHandleBase
{
123 TLinker(EShExecutable e
, TInfoSink
& iSink
) :
126 haveReturnableObjectCode(false),
127 appAttributeBindings(0),
128 fixedAttributeBindings(0),
129 excludedAttributes(0),
131 uniformBindings(0) { }
132 virtual TLinker
* getAsLinker() { return this; }
133 virtual ~TLinker() { }
134 virtual bool link(TCompilerList
&, TUniformMap
*) = 0;
135 virtual bool link(THandleList
&) { return false; }
136 virtual void setAppAttributeBindings(const ShBindingTable
* t
) { appAttributeBindings
= t
; }
137 virtual void setFixedAttributeBindings(const ShBindingTable
* t
) { fixedAttributeBindings
= t
; }
138 virtual void getAttributeBindings(ShBindingTable
const **t
) const = 0;
139 virtual void setExcludedAttributes(const int* attributes
, int count
) { excludedAttributes
= attributes
; excludedCount
= count
; }
140 virtual ShBindingTable
* getUniformBindings() const { return uniformBindings
; }
141 virtual const void* getObjectCode() const { return 0; } // a real compiler would be returning object code here
142 virtual TInfoSink
& getInfoSink() { return infoSink
; }
145 EShExecutable executable
;
146 bool haveReturnableObjectCode
; // true when objectCode is acceptable to send to driver
148 const ShBindingTable
* appAttributeBindings
;
149 const ShBindingTable
* fixedAttributeBindings
;
150 const int* excludedAttributes
;
152 ShBindingTable
* uniformBindings
; // created by the linker
156 // This is the interface between the machine independent code
157 // and the machine dependent code.
159 // The machine dependent code should derive from the classes
160 // above. Then Construct*() and Delete*() will create and
161 // destroy the machine dependent objects, which contain the
162 // above machine independent information.
164 TCompiler
* ConstructCompiler(EShLanguage
, int);
166 TShHandleBase
* ConstructLinker(EShExecutable
, int);
167 TShHandleBase
* ConstructBindings();
168 TShHandleBase
* ConstructLibrary();
169 void DeleteLinker(TShHandleBase
*);
171 TUniformMap
* ConstructUniformMap();
172 void DeleteCompiler(TCompiler
*);
174 void DeleteUniformMap(TUniformMap
*);
175 void freeTargetDependentData(void*);
177 #endif // _SHHANDLE_INCLUDED_