327 lines
11 KiB
C++
327 lines
11 KiB
C++
/*
|
||
*
|
||
* Copyright (c) 2002, NVIDIA Corporation.
|
||
*
|
||
*
|
||
*
|
||
* NVIDIA Corporation("NVIDIA") supplies this software to you in consideration
|
||
* of your agreement to the following terms, and your use, installation,
|
||
* modification or redistribution of this NVIDIA software constitutes
|
||
* acceptance of these terms. If you do not agree with these terms, please do
|
||
* not use, install, modify or redistribute this NVIDIA software.
|
||
*
|
||
*
|
||
*
|
||
* In consideration of your agreement to abide by the following terms, and
|
||
* subject to these terms, NVIDIA grants you a personal, non-exclusive license,
|
||
* under NVIDIA’s copyrights in this original NVIDIA software (the "NVIDIA
|
||
* Software"), to use, reproduce, modify and redistribute the NVIDIA
|
||
* Software, with or without modifications, in source and/or binary forms;
|
||
* provided that if you redistribute the NVIDIA Software, you must retain the
|
||
* copyright notice of NVIDIA, this notice and the following text and
|
||
* disclaimers in all such redistributions of the NVIDIA Software. Neither the
|
||
* name, trademarks, service marks nor logos of NVIDIA Corporation may be used
|
||
* to endorse or promote products derived from the NVIDIA Software without
|
||
* specific prior written permission from NVIDIA. Except as expressly stated
|
||
* in this notice, no other rights or licenses express or implied, are granted
|
||
* by NVIDIA herein, including but not limited to any patent rights that may be
|
||
* infringed by your derivative works or by other works in which the NVIDIA
|
||
* Software may be incorporated. No hardware is licensed hereunder.
|
||
*
|
||
*
|
||
*
|
||
* THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT
|
||
* WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
|
||
* WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
|
||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR ITS USE AND OPERATION
|
||
* EITHER ALONE OR IN COMBINATION WITH OTHER PRODUCTS.
|
||
*
|
||
*
|
||
*
|
||
* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
|
||
* EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOST
|
||
* PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||
* PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY OUT OF THE USE,
|
||
* REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE NVIDIA SOFTWARE,
|
||
* HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING
|
||
* NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF NVIDIA HAS BEEN ADVISED
|
||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*
|
||
*/
|
||
|
||
/*********************************************************************NVMH2****
|
||
File: cgProgramManager.h
|
||
|
||
Copyright (C) 1999, 2000 NVIDIA Corporation
|
||
This file is provided without support, instruction, or implied warranty of any
|
||
kind. NVIDIA makes no guarantee of its fitness for a particular purpose and is
|
||
not liable under any circumstances for any damages or loss whatsoever arising
|
||
from the use or inability to use this file or items derived from it.
|
||
|
||
Comments:
|
||
|
||
cgProgramManager - a class for loading various pixel & vertex shaders
|
||
|
||
|
||
******************************************************************************/
|
||
|
||
|
||
#ifndef __NV_PROGRAM_MANAGER_H
|
||
#define __NV_PROGRAM_MANAGER_H
|
||
|
||
#if WIN32
|
||
|
||
#pragma warning (disable:4786) // identifier was truncated to '255' characters in the browser information
|
||
|
||
#include <windows.h>
|
||
#include <d3d8.h>
|
||
#include <d3dx8.h>
|
||
|
||
#include <Cg/cgTemplates.h>
|
||
#include <Cg/cg.h>
|
||
|
||
|
||
|
||
// to allow multiple streams and user specifed vertex type
|
||
// D3DVSDT_FLOAT1 0x00 // 1D float expanded to (value, 0., 0., 1.)
|
||
// D3DVSDT_FLOAT2 0x01 // 2D float expanded to (value, value, 0., 1.)
|
||
// D3DVSDT_FLOAT3 0x02 // 3D float expanded to (value, value, value, 1.)
|
||
// D3DVSDT_FLOAT4 0x03 // 4D float
|
||
// D3DVSDT_D3DCOLOR 0x04 // 4D packed unsigned bytes mapped to 0. to 1. range
|
||
// // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
|
||
// D3DVSDT_UBYTE4 0x05 // 4D unsigned byte
|
||
// D3DVSDT_SHORT2 0x06 // 2D signed short expanded to (value, value, 0., 1.)
|
||
// D3DVSDT_SHORT4 0x07 // 4D signed short
|
||
|
||
|
||
// was cgVertexAttribute
|
||
typedef struct cgVertexDefinition
|
||
{
|
||
int D3DVSDT_type; // one of D3DVSDT_*
|
||
char * name; // name of the entry
|
||
int stream; // stream to put the vertex in
|
||
} cgVertexDefinition;
|
||
|
||
|
||
#define CGVERTEXDEFINITIONEND {-1, 0, 0}
|
||
|
||
// internal cgDirect3D data structure
|
||
typedef struct cgiVertexAttribute
|
||
{
|
||
char name[64];
|
||
int D3DVSDT_type;
|
||
int bind_location;
|
||
cgBindIter * BindIter;
|
||
} cgiVertexAttribute;
|
||
|
||
|
||
|
||
typedef cg_vector<cgiVertexAttribute> cgiVertexAttributeList;
|
||
typedef cg_list<cgBindIter *> cgBindIterList;
|
||
|
||
|
||
class cgProgramManager;
|
||
class cgContextContainer;
|
||
|
||
class cgProgramContainer
|
||
{
|
||
|
||
public:
|
||
|
||
// get a text definition of what the runtime expects for the vertex
|
||
const char * GetVertexDeclaration();
|
||
/*
|
||
Example: returns string containing
|
||
"struct stream0
|
||
{
|
||
D3DXVECTOR3 position;
|
||
D3DXVECTOR2 tex0;
|
||
};"
|
||
|
||
*/
|
||
|
||
|
||
|
||
|
||
// convert D3DXMATRIX class to type specified in cg program
|
||
// even if your cg program uses 3x3, you can use this to pass a matrix to it
|
||
// upper left hand part of D3DXMATRIX is used to fill the cg matrix
|
||
HRESULT SetShaderConstantD3DXMATRIX(cgBindIter * iter, const D3DXMATRIX *, int nArrayElements = 0, int ArrayOffset = 0);
|
||
|
||
|
||
|
||
// All other data formats use this interface
|
||
// The D3D runtime records the size of your data and puts that in the constant fields
|
||
HRESULT SetShaderConstant(cgBindIter * iter, void * data, int nArrayElements = 0, int ArrayOffset = 0);
|
||
// for arrays:
|
||
// if nArrayElements is specified, write this number of elements rather than the whole array
|
||
// if ArrayOffset is specified, start writing at this array element
|
||
// otherwise nArrayElements and ArrayOffset are not specified
|
||
|
||
|
||
// returns texture position 0-8 for the iterator
|
||
// -1 is failure
|
||
int GetTexturePosition(cgBindIter * BindIter);
|
||
int GetTexturePosition(const char * name);
|
||
|
||
// set the texture via name (needs to search bindings by name, so this is the slowest
|
||
// not recommended
|
||
HRESULT SetTexture(const char * name, LPDIRECT3DBASETEXTURE8 pTexture);
|
||
|
||
// does a GetTexturePosition, then settexture(n, nTexture)
|
||
HRESULT SetTexture(cgBindIter * BindIter, LPDIRECT3DBASETEXTURE8 pTexture);
|
||
|
||
// does a GetTexturePosition, then SetTextureStageState(n, nTexture, Value)
|
||
HRESULT SetTextureStageState(cgBindIter * BindIter, D3DTEXTURESTAGESTATETYPE Type,DWORD Value);
|
||
|
||
// Direct3D hardcodes wrap state, D3DRS_WRAP1, D3DWRAPCOORD_0 | D3DWRAPCOORD_1
|
||
// WrapCoords : 0, D3DWRAPCOORD_0, D3DWRAPCOORD_1 or'd together
|
||
HRESULT SetTextureWrapMode(cgBindIter * BindIter, DWORD WrapCoords);
|
||
|
||
|
||
// activate this shader (SetVertexShader or SetPixelShader)
|
||
HRESULT SetShaderActive();
|
||
|
||
|
||
// locate a binding within a program by parameter name
|
||
// it is recommended to do this once and use the cgBindIter to reference data
|
||
cgBindIter *GetVertexBindByName(const char *vertex_attr_name);
|
||
cgBindIter *GetTextureBindByName(const char *texture_name);
|
||
cgBindIter *GetParameterBindByName(const char *parameter_name);
|
||
|
||
void FreeBindIter(cgBindIter *);
|
||
|
||
|
||
|
||
|
||
// Get the type for this bind iterator
|
||
cgValueType GetBindValueType(const cgBindIter *BindIter, int *array_size)
|
||
{
|
||
return cgGetBindValueType(BindIter, array_size);
|
||
}
|
||
|
||
|
||
// locate and bindinf iterator by full name
|
||
// e.g. appdata.texcoord0
|
||
cgBindIter *GetBindByFullName(const char *parameter_name);
|
||
|
||
// from the iterator, get the name of the program
|
||
const char *GetProgramName();
|
||
|
||
const char *GetProgramObjectCode();
|
||
|
||
cgProfileType GetProgramProfile() { return m_ProfileType;}
|
||
|
||
// get the shader handle passed to Direct3D
|
||
DWORD GetShaderHandle() {return m_dwShaderHandle;}
|
||
|
||
private:
|
||
|
||
cgBindIter *AllocBind();
|
||
void SaveBind(cgBindIter * BindIter); // for deleting
|
||
|
||
cgBindIterList m_BindIterList;
|
||
|
||
void GetParameterConstantPosition(cgBindIter * iter, int * pos, int *width, int * num4vectors, int *nArrayElements);
|
||
void GetParameterConstantPosition(const char * name, int * pos, int *width, int * num4vectors, int *nArrayElements);
|
||
|
||
|
||
HRESULT CreateProgramShader();
|
||
HRESULT CreateVertexShader();
|
||
HRESULT CreatePixelShader();
|
||
|
||
// take asm code, assembles it and create a handle
|
||
HRESULT CreateShaderHandleFromFile(
|
||
const cg_string & strFilePath,
|
||
const cg_string & strSourceFile,
|
||
const DWORD * pDeclaration,
|
||
DWORD Usage);
|
||
|
||
HRESULT CreateShaderHandleFromMemory(
|
||
const char * pShaderText,
|
||
const DWORD * pDeclaration,
|
||
DWORD Usage);
|
||
|
||
|
||
HRESULT Free();
|
||
|
||
|
||
// cgDX8VertexProfile or cgDX8PixelProfile (cg_profiles.h)
|
||
// These types are defined with macros:
|
||
// CG_PROFILE_MACRO(DX8Vertex,dx8vs,"dx8vs")
|
||
// CG_PROFILE_MACRO(DX8Pixel,dx8ps,"dx8ps")
|
||
|
||
|
||
friend cgProgramManager;
|
||
friend cgContextContainer;
|
||
DWORD m_dwShaderHandle; // DWORD handle returned by DX8 runtime
|
||
cgProfileType m_ProfileType; // profile for this program
|
||
HRESULT SetVertexDefinition(cgVertexDefinition * streams);
|
||
|
||
|
||
cgProgramContainer(LPDIRECT3DDEVICE8 pDev, cgProgramIter *m_ProgramIter,
|
||
cgProfileType ProfileType);
|
||
~cgProgramContainer();
|
||
|
||
|
||
HRESULT LoadShaderConstants();
|
||
cg_string m_ProgramSourceFile; // text file name
|
||
cg_string m_ProgramObjectFile; // compiled shader object file (.vso, .pso)
|
||
|
||
// for declaration of vertex positions
|
||
cgiVertexAttributeList m_VertexAttributes[MAX_STREAMS];
|
||
|
||
cgProgramIter *m_ProgramIter;
|
||
|
||
|
||
LPDIRECT3DDEVICE8 m_pd3dDevice;
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
class cgProgramManager
|
||
{
|
||
private:
|
||
cg_vector < cgProgramContainer * > m_ProgramContainers; // m_Shaders[0] is always = 0
|
||
cg_vector < DWORD > m_ProgramIndices; // indirection to m_Shaders
|
||
// Programs hold an index to this array for
|
||
// their shaders. The array int at that index
|
||
// holds the index into the m_Shaders array.
|
||
|
||
public:
|
||
|
||
|
||
cgProgramManager(LPDIRECT3DDEVICE8 pDev);
|
||
~cgProgramManager();
|
||
|
||
HRESULT Free();
|
||
|
||
|
||
cgProgramContainer * CreateProgramContainer(LPDIRECT3DDEVICE8 pDev,
|
||
cgProgramIter * ProgramIter,
|
||
DWORD Usage,
|
||
cgProfileType ProfileType,
|
||
DWORD * outIndex );
|
||
|
||
|
||
|
||
DWORD GetShaderHandle( DWORD Index );
|
||
DWORD GetShaderHandle( cgProfileType ProfileType );
|
||
|
||
//
|
||
cgProgramContainer * GetProgramIterator(DWORD index);
|
||
|
||
|
||
|
||
private:
|
||
// for creating programs
|
||
LPDIRECT3DDEVICE8 m_pd3dDevice;
|
||
|
||
};
|
||
|
||
#endif // WIN32
|
||
|
||
#endif
|