2 // Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
3 // All rights reserved.
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/ShaderLang.h"
47 #include "../MachineIndependent/Versions.h"
55 // The base class used to back handles returned to the driver.
60 virtual ~TShHandleBase() { }
61 virtual TCompiler* getAsCompiler() { return 0; }
62 virtual TLinker* getAsLinker() { return 0; }
63 virtual TUniformMap* getAsUniformMap() { return 0; }
67 // The base class for the machine dependent linker to derive from
68 // for managing where uniforms live.
70 class TUniformMap : public TShHandleBase {
73 virtual ~TUniformMap() { }
74 virtual TUniformMap* getAsUniformMap() { return this; }
75 virtual int getLocation(const char* name) = 0;
76 virtual TInfoSink& getInfoSink() { return infoSink; }
83 // The base class for the machine dependent compiler to derive from
84 // for managing object code from the compile.
86 class TCompiler : public TShHandleBase {
88 TCompiler(EShLanguage l, TInfoSink& sink) : infoSink(sink) , language(l), haveValidObjectCode(false) { }
89 virtual ~TCompiler() { }
90 EShLanguage getLanguage() { return language; }
91 virtual TInfoSink& getInfoSink() { return infoSink; }
93 virtual bool compile(TIntermNode* root, int version = 0, EProfile profile = ENoProfile) = 0;
95 virtual TCompiler* getAsCompiler() { return this; }
96 virtual bool linkable() { return haveValidObjectCode; }
100 TCompiler& operator=(TCompiler&);
102 EShLanguage language;
103 bool haveValidObjectCode;
107 // Link operations are based on a list of compile results...
109 typedef glslang::TVector<TCompiler*> TCompilerList;
110 typedef glslang::TVector<TShHandleBase*> THandleList;
113 // The base class for the machine dependent linker to derive from
114 // to manage the resulting executable.
117 class TLinker : public TShHandleBase {
119 TLinker(EShExecutable e, TInfoSink& iSink) :
122 haveReturnableObjectCode(false),
123 appAttributeBindings(0),
124 fixedAttributeBindings(0),
125 excludedAttributes(0),
127 uniformBindings(0) { }
128 virtual TLinker* getAsLinker() { return this; }
129 virtual ~TLinker() { }
130 virtual bool link(TCompilerList&, TUniformMap*) = 0;
131 virtual bool link(THandleList&) { return false; }
132 virtual void setAppAttributeBindings(const ShBindingTable* t) { appAttributeBindings = t; }
133 virtual void setFixedAttributeBindings(const ShBindingTable* t) { fixedAttributeBindings = t; }
134 virtual void getAttributeBindings(ShBindingTable const **t) const = 0;
135 virtual void setExcludedAttributes(const int* attributes, int count) { excludedAttributes = attributes; excludedCount = count; }
136 virtual ShBindingTable* getUniformBindings() const { return uniformBindings; }
137 virtual const void* getObjectCode() const { return 0; } // a real compiler would be returning object code here
138 virtual TInfoSink& getInfoSink() { return infoSink; }
141 TLinker& operator=(TLinker&);
142 EShExecutable executable;
143 bool haveReturnableObjectCode; // true when objectCode is acceptable to send to driver
145 const ShBindingTable* appAttributeBindings;
146 const ShBindingTable* fixedAttributeBindings;
147 const int* excludedAttributes;
149 ShBindingTable* uniformBindings; // created by the linker
153 // This is the interface between the machine independent code
154 // and the machine dependent code.
156 // The machine dependent code should derive from the classes
157 // above. Then Construct*() and Delete*() will create and
158 // destroy the machine dependent objects, which contain the
159 // above machine independent information.
161 TCompiler* ConstructCompiler(EShLanguage, int);
163 TShHandleBase* ConstructLinker(EShExecutable, int);
164 TShHandleBase* ConstructBindings();
165 void DeleteLinker(TShHandleBase*);
166 void DeleteBindingList(TShHandleBase* bindingList);
168 TUniformMap* ConstructUniformMap();
169 void DeleteCompiler(TCompiler*);
171 void DeleteUniformMap(TUniformMap*);
173 #endif // _SHHANDLE_INCLUDED_