abian/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Single pass player color rendering.

Browse Source 
Falls back to a simpler formula when only 2 TMUs are available.
CRenderer is now a JS object called "renderer" for scripting.

This was SVN commit r2891.
This commit is contained in:
prefect 2005-10-10 14:15:28 +00:00
parent 868649d491
commit 6efb1e1c00
8 changed files with 179 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/ps/GameSetup/GameSetup.cpp
View File

@ -712,14 +712,12 @@ void Shutdown()
// Managed by CWorld
// delete &g_EntityManager;
TIMER_START("shutdown scripting stuff");
TIMER_START("shutdown game scripting stuff");
delete &g_GameAttributes;
delete &g_JSGameEvents;
delete &g_EntityTemplateCollection;
delete &g_ScriptingHost;
TIMER_END("shutdown scripting stuff");
TIMER_END("shutdown game scripting stuff");
// destroy actor related stuff
TIMER_START("shutdown actor stuff");
@ -742,6 +740,10 @@ void Shutdown()
g_VBMan.Shutdown();
TIMER_END("shutdown Renderer");
TIMER_START("shutdown ScriptingHost");
delete &g_ScriptingHost;
TIMER_END("shutdown ScriptingHost");
TIMER_START("shutdown ConfigDB");
delete &g_ConfigDB;
TIMER_END("shutdown ConfigDB");
@ -878,7 +880,7 @@ void Init(int argc, char* argv[], bool setup_gfx, bool setup_gui)
}
// (must come after SetVideoMode, since it calls oglInit)
const char* missing = oglHaveExtensions(0, "GL_ARB_multitexture", "GL_ARB_texture_env_combine", "GL_ARB_texture_env_dot3", 0);
const char* missing = oglHaveExtensions(0, "GL_ARB_multitexture", "GL_ARB_texture_env_combine", "GL_ARB_texture_env_dot3", "GL_ARB_texture_env_crossbar", 0);
if(missing)
{
wchar_t buf[500];

18
source/renderer/ModelRData.cpp
View File

@ -283,18 +283,19 @@ void CModelRData::FinishRender(u32 streamflags)
// Render one indiviual model.
// Try to use RenderModels instead wherever possible.
// Must be bracketed by calls to CModelRData::SetupRender/FinishRender
void CModelRData::RenderStreams(u32 streamflags, bool isplayer)
void CModelRData::RenderStreams(u32 streamflags, int tmus)
{
CModelDefPtr mdldef=m_Model->GetModelDef();
if (streamflags & STREAM_UV0)
{
if(!isplayer)
m_Model->GetMaterial().Bind();
else
g_Renderer.SetTexture(1,m_Model->GetTexture());
g_Renderer.SetTexture(0,m_Model->GetTexture());
if (tmus > 1)
{
for(int i = 1; i < tmus; ++i)
g_Renderer.SetTexture(i, m_Model->GetTexture());
}
g_Renderer.SetTexture(0, m_Model->GetTexture());
}
u8* base = m_DynamicArray.Bind();
@ -325,9 +326,6 @@ void CModelRData::RenderStreams(u32 streamflags, bool isplayer)
size_t numFaces=mdldef->GetNumFaces();
glDrawRangeElementsEXT(GL_TRIANGLES,0,mdldef->GetNumVertices(),numFaces*3,GL_UNSIGNED_SHORT,m_Indices);
if(streamflags & STREAM_UV0 & !isplayer)
m_Model->GetMaterial().Unbind();
// bump stats
g_Renderer.m_Stats.m_DrawCalls++;
g_Renderer.m_Stats.m_ModelTris+=numFaces;

2
source/renderer/ModelRData.h
View File

@ -22,7 +22,7 @@ public:
~CModelRData();
void Update();
void RenderStreams(u32 streamflags, bool isplayer = false);
void RenderStreams(u32 streamflags, int tmus = 1);
// return render flags for this model
u32 GetFlags() const { return m_Flags; }

213
source/renderer/PlayerRenderer.cpp
View File

@ -18,40 +18,12 @@
#include "Game.h"
#include "Profile.h"
#include "ps/CLogger.h"
#define LOG_CATEGORY "graphics"
CPlayerRenderer g_PlayerRenderer;
///////////////////////////////////////////////////////////////////////////////////////////////////
// SetupColorRenderStates: setup the render states for the player color pass.
void CPlayerRenderer::SetupColorRenderStates()
{
// Set up second pass: first texture unit carries on doing texture*lighting,
// but passes alpha through inverted; the second texture unit modulates
// with the player colour.
glActiveTextureARB(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_ONE_MINUS_SRC_ALPHA);
glActiveTextureARB(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
// t1 = t0 * playercolor
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Continue passing through alpha from texture
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Render: render all deferred passes; call Sort before using to ensure passes
@ -62,62 +34,128 @@ void CPlayerRenderer::Render()
if (m_Objects.size()==0) return;
if (g_Renderer.m_NicePlayerColor && ogl_max_tex_units < 3)
{
g_Renderer.m_NicePlayerColor = false;
LOG(WARNING, LOG_CATEGORY, "Using fallback player color rendering (not enough TMUs).");
}
// switch on wireframe if we need it
if (g_Renderer.m_ModelRenderMode==WIREFRAME) {
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
}
// set up texture environment for base pass - modulate texture and primary color
glActiveTextureARB(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Set the proper LOD bias
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
// Render two passes: first, render the unit as normal. Second,
// render it again but modulated with the player-colour, using
// the alpha channel as a mask.
// EDIT: The second pass resides in SetupColorRenderStates() [John M. Mena]
//
// This really ought to be done in a single pass on hardware that
// supports register combiners / fragment programs / etc (since it
// would only need a single pass and no blending)
}
if (g_Renderer.m_NicePlayerColor)
{
// Nice player color uses a single pass with three texture environments
// Note: This uses ARB_texture_env_crossbar (which is checked in GameSetup)
//
// We calculate: Result = Color*Texture*(PlayerColor*(1-Texture.a) + 1.0*Texture.a)
// Algebra gives us:
// Result = (1 - ((1 - PlayerColor) * (1 - Texture.a)))*Texture*Color
// TexEnv #0
glActiveTextureARB(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_ONE_MINUS_SRC_COLOR);
// Don't care about alpha; set it to something harmless
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
// TexEnv #1
glActiveTextureARB(GL_TEXTURE0+1);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_ONE_MINUS_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Don't care about alpha; set it to something harmless
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
// TexEnv #2
glActiveTextureARB(GL_TEXTURE0+2);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Don't care about alpha; set it to something harmless
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
glActiveTextureARB(GL_TEXTURE0);
}
else
{
// Non-nice player color uses a single pass with two texture environments,
// but has a different result than Nice player color.
//
// Rationale: Any graphics card that only has 2 TMUs is likely to be
// slow; I don't want to bog it down even more with multipass.
//
// We calculate: Result = Color*(Texture.rgb*Texture.a + PlayerColor*(1-Texture.a))
// TexEnv #0
glActiveTextureARB(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);
// Don't care about alpha; set it to something harmless
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
// TexEnv #1
glActiveTextureARB(GL_TEXTURE0+1);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Don't care about alpha; set it to something harmless
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
glActiveTextureARB(GL_TEXTURE0);
}
CModelRData::SetupRender(STREAM_POS|STREAM_COLOR|STREAM_UV0);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
// First pass should ignore the alpha channel and render the whole model
glDisable(GL_ALPHA_TEST);
RenderObjectsStreams(STREAM_POS|STREAM_COLOR|STREAM_UV0);
// Render the second pass:
// Second pass uses the alpha channel to blend the coloured model
// with the first pass's solid model
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0);
RenderObjectsStreams(STREAM_POS|STREAM_COLOR|STREAM_UV0, true);
// Restore states
glActiveTextureARB(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
if (g_Renderer.m_NicePlayerColor)
{
glActiveTextureARB(GL_TEXTURE2);
glDisable(GL_TEXTURE_2D);
}
glActiveTextureARB(GL_TEXTURE0);
CModelRData::FinishRender(STREAM_POS|STREAM_COLOR|STREAM_UV0);
@ -176,30 +214,33 @@ void CPlayerRenderer::RenderShadows()
// RenderObjectsStreams: render given streams on all objects
void CPlayerRenderer::RenderObjectsStreams(u32 streamflags, bool iscolorpass, u32 mflags)
{
int tmus = 1;
if (iscolorpass)
{
if (g_Renderer.m_NicePlayerColor)
tmus = 3;
else
tmus = 2;
}
for (uint i=0;i<m_Objects.size();++i) {
if (!mflags || (m_Objects[i]->GetFlags() & mflags)) {
CModelRData* modeldata=(CModelRData*) m_Objects[i]->GetRenderData();
// Setup the render states to apply the second texture ( i.e. player color )
// Pass the player color as a TexEnv constant when applicable
if (iscolorpass)
{
// I, John Mena, don't think that both passes need a color applied.
// If I am wrong, then just move everything except for the
// SetupColorRenderStates() below this if statement.
// Get the player color
SMaterialColor colour = m_Objects[i]->GetMaterial().GetPlayerColor();
float* color = &colour.r; // because it's stored RGBA
// Just like it says, Sets up the player color render states
SetupColorRenderStates();
// Set the texture environment color the player color
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
}
// Render the model
modeldata->RenderStreams(streamflags, iscolorpass);
modeldata->RenderStreams(streamflags, tmus);
}
}
}

4
source/renderer/PlayerRenderer.h
View File

@ -31,12 +31,10 @@ public:
private:
// render given streams on all objects
void RenderObjectsStreams(u32 streamflags, bool iscolorpass=false, u32 mflags=0);
// setup the second pass for the player color
void SetupColorRenderStates();
// list of objects to render
std::vector<CModel*> m_Objects;
};
extern CPlayerRenderer g_PlayerRenderer;
#endif
#endif

16
source/renderer/Renderer.cpp
View File

@ -68,6 +68,7 @@ CRenderer::CRenderer()
m_Options.m_Shadows=true;
m_Options.m_ShadowColor=RGBAColor(0.4f,0.4f,0.4f,1.0f);
m_Options.m_RenderPath = RP_DEFAULT;
m_NicePlayerColor = true;
for (uint i=0;i<MaxTextureUnits;i++) {
m_ActiveTextures[i]=0;
@ -101,7 +102,8 @@ CRenderer::CRenderer()
else
ogl_tex_upload(m_WaterTexture[x]);
}
ONCE( ScriptingInit(); );
}
///////////////////////////////////////////////////////////////////////////////////
@ -1462,3 +1464,15 @@ void CRenderer::UnloadAlphaMaps()
{
ogl_tex_free(m_hCompositeAlphaMap);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Scripting Interface
void CRenderer::ScriptingInit()
{
AddProperty(L"nicePlayerColor", &CRenderer::m_NicePlayerColor);
CJSObject<CRenderer>::ScriptingInit("Renderer");
}

10
source/renderer/Renderer.h
View File

@ -24,6 +24,8 @@
#include "Singleton.h"
#include "Overlay.h"
#include "scripting/ScriptableObject.h"
// necessary declarations
class CCamera;
class CPatch;
@ -73,7 +75,7 @@ struct SVertex2D
///////////////////////////////////////////////////////////////////////////////////////////
// CRenderer: base renderer class - primary interface to the rendering engine
class CRenderer : public Singleton<CRenderer>
class CRenderer : public Singleton<CRenderer>, public CJSObject<CRenderer>
{
private:
std::vector<CPatch*> m_VisiblePatches;
@ -262,6 +264,9 @@ protected:
friend class CPlayerRenderer;
friend class RenderPathVertexShader;
// scripting
static void ScriptingInit();
// patch rendering stuff
void RenderPatchSubmissions();
void RenderPatches();
@ -356,6 +361,9 @@ protected:
// Additional state that is only available when the vertex shader
// render path is used (according to m_Options.m_RenderPath)
RenderPathVertexShader* m_VertexShader;
// If false, use a simpler, two-texture unit fallback for player colors.
bool m_NicePlayerColor;
};

11
source/scripting/ScriptGlue.cpp
View File

@ -1047,6 +1047,16 @@ JSBool GetGameView( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(i
}
JSBool GetRenderer( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
{
if (CRenderer::IsInitialised())
*vp = OBJECT_TO_JSVAL( g_Renderer.GetScript() );
else
*vp = JSVAL_NULL;
return( JS_TRUE );
}
enum ScriptGlobalTinyIDs
{
GLOBAL_SELECTION,
@ -1070,6 +1080,7 @@ JSPropertySpec ScriptGlobalTable[] =
{ "localPlayer", 0, PERM , GetLocalPlayer, SetLocalPlayer },
{ "gaiaPlayer" , 0, PERM | CONST, GetGaiaPlayer, 0 },
{ "gameView" , 0, PERM | CONST, GetGameView, 0 },
{ "renderer" , 0, PERM | CONST, GetRenderer, 0 },
// end of table marker
{ 0, 0, 0, 0, 0 },