Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

# IGPUProgrammingServices.h

Go to the documentation of this file.

    00001 // Copyright (C) 2002-2009 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine".
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
    00004
    00005 #ifndef __I_GPU_PROGRAMMING_SERVICES_H_INCLUDED__
    00006 #define __I_GPU_PROGRAMMING_SERVICES_H_INCLUDED__
    00007
    00008 #include "EShaderTypes.h"
    00009 #include "EMaterialTypes.h"
    00010 #include "EPrimitiveTypes.h"
    00011 #include "path.h"
    00012
    00013 namespace irr
    00014 {
    00015
    00016 namespace io
    00017 {
    00018         class IReadFile;
    00019 } // end namespace io
    00020
    00021 namespace video
    00022 {
    00023
    00024 class IVideoDriver;
    00025 class IShaderConstantSetCallBack;
    00026
    00028 class IGPUProgrammingServices
    00029 {
    00030 public:
    00031
    00033         virtual ~IGPUProgrammingServices() {}
    00034
    00036
    00076         virtual s32 addHighLevelShaderMaterial(
    00077                 const c8* vertexShaderProgram,
    00078                 const c8* vertexShaderEntryPointName,
    00079                 E_VERTEX_SHADER_TYPE vsCompileTarget,
    00080                 const c8* pixelShaderProgram,
    00081                 const c8* pixelShaderEntryPointName,
    00082                 E_PIXEL_SHADER_TYPE psCompileTarget,
    00083                 const c8* geometryShaderProgram,
    00084                 const c8* geometryShaderEntryPointName = "main",
    00085                 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
    00086                 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
    00087                 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
    00088                 u32 verticesOut = 0,
    00089                 IShaderConstantSetCallBack* callback = 0,
    00090                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00091                 s32 userData = 0 ) = 0;
    00092
    00094         s32 addHighLevelShaderMaterial(
    00095                 const c8* vertexShaderProgram,
    00096                 const c8* vertexShaderEntryPointName = "main",
    00097                 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
    00098                 const c8* pixelShaderProgram = 0,
    00099                 const c8* pixelShaderEntryPointName = "main",
    00100                 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
    00101                 IShaderConstantSetCallBack* callback = 0,
    00102                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00103                 s32 userData = 0 )
    00104         {
    00105                 return addHighLevelShaderMaterial(
    00106                         vertexShaderProgram, vertexShaderEntryPointName,
    00107                         vsCompileTarget, pixelShaderProgram,
    00108                         pixelShaderEntryPointName, psCompileTarget,
    00109                         0, "main", EGST_GS_4_0,
    00110                         scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
    00111                         callback, baseMaterial, userData);
    00112         }
    00113
    00115
    00156         virtual s32 addHighLevelShaderMaterialFromFiles(
    00157                 const io::path& vertexShaderProgramFileName,
    00158                 const c8* vertexShaderEntryPointName,
    00159                 E_VERTEX_SHADER_TYPE vsCompileTarget,
    00160                 const io::path& pixelShaderProgramFileName,
    00161                 const c8* pixelShaderEntryPointName,
    00162                 E_PIXEL_SHADER_TYPE psCompileTarget,
    00163                 const io::path& geometryShaderProgramFileName,
    00164                 const c8* geometryShaderEntryPointName = "main",
    00165                 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
    00166                 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
    00167                 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
    00168                 u32 verticesOut = 0,
    00169                 IShaderConstantSetCallBack* callback = 0,
    00170                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00171                 s32 userData = 0) = 0;
    00172
    00174         s32 addHighLevelShaderMaterialFromFiles(
    00175                 const io::path& vertexShaderProgramFileName,
    00176                 const c8* vertexShaderEntryPointName = "main",
    00177                 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
    00178                 const io::path& pixelShaderProgramFileName = "",
    00179                 const c8* pixelShaderEntryPointName = "main",
    00180                 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
    00181                 IShaderConstantSetCallBack* callback = 0,
    00182                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00183                 s32 userData = 0)
    00184         {
    00185                 return addHighLevelShaderMaterialFromFiles(
    00186                         vertexShaderProgramFileName, vertexShaderEntryPointName,
    00187                         vsCompileTarget, pixelShaderProgramFileName,
    00188                         pixelShaderEntryPointName, psCompileTarget,
    00189                         "", "main", EGST_GS_4_0,
    00190                         scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
    00191                         callback, baseMaterial, userData);
    00192         }
    00193
    00195
    00234         virtual s32 addHighLevelShaderMaterialFromFiles(
    00235                 io::IReadFile* vertexShaderProgram,
    00236                 const c8* vertexShaderEntryPointName,
    00237                 E_VERTEX_SHADER_TYPE vsCompileTarget,
    00238                 io::IReadFile* pixelShaderProgram,
    00239                 const c8* pixelShaderEntryPointName,
    00240                 E_PIXEL_SHADER_TYPE psCompileTarget,
    00241                 io::IReadFile* geometryShaderProgram,
    00242                 const c8* geometryShaderEntryPointName = "main",
    00243                 E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
    00244                 scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
    00245                 scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
    00246                 u32 verticesOut = 0,
    00247                 IShaderConstantSetCallBack* callback = 0,
    00248                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00249                 s32 userData = 0) = 0;
    00250
    00252         s32 addHighLevelShaderMaterialFromFiles(
    00253                 io::IReadFile* vertexShaderProgram,
    00254                 const c8* vertexShaderEntryPointName = "main",
    00255                 E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
    00256                 io::IReadFile* pixelShaderProgram = 0,
    00257                 const c8* pixelShaderEntryPointName = "main",
    00258                 E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
    00259                 IShaderConstantSetCallBack* callback = 0,
    00260                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00261                 s32 userData = 0)
    00262         {
    00263                 return addHighLevelShaderMaterialFromFiles(
    00264                         vertexShaderProgram, vertexShaderEntryPointName,
    00265                         vsCompileTarget, pixelShaderProgram,
    00266                         pixelShaderEntryPointName, psCompileTarget,
    00267                         0, "main", EGST_GS_4_0,
    00268                         scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
    00269                         callback, baseMaterial, userData);
    00270         }
    00271
    00273
    00306         virtual s32 addShaderMaterial(const c8* vertexShaderProgram = 0,
    00307                 const c8* pixelShaderProgram = 0,
    00308                 IShaderConstantSetCallBack* callback = 0,
    00309                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00310                 s32 userData = 0) = 0;
    00311
    00313
    00330         virtual s32 addShaderMaterialFromFiles(io::IReadFile* vertexShaderProgram,
    00331                 io::IReadFile* pixelShaderProgram,
    00332                 IShaderConstantSetCallBack* callback = 0,
    00333                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00334                 s32 userData = 0) = 0;
    00335
    00337
    00355         virtual s32 addShaderMaterialFromFiles(const io::path& vertexShaderProgramFileName,
    00356                 const io::path& pixelShaderProgramFileName,
    00357                 IShaderConstantSetCallBack* callback = 0,
    00358                 E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
    00359                 s32 userData = 0) = 0;
    00360 };
    00361
    00362
    00363 } // end namespace video
    00364 } // end namespace irr
    00365
    00366 #endif
    00367

| The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Feb 14 13:06:56 2010 by Doxygen (1.6.2)