391 lines
7.2 KiB
Rust
391 lines
7.2 KiB
Rust
use std::collections::*;
|
|
|
|
use crate::glezz;
|
|
use crate::shader_closure::*;
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub enum FrontFace {
|
|
Cw,
|
|
Ccw,
|
|
}
|
|
|
|
impl From <FrontFace> for u32 {
|
|
fn from (v: FrontFace) -> Self {
|
|
use FrontFace::*;
|
|
{
|
|
use gl::*;
|
|
match v {
|
|
Cw => CW,
|
|
Ccw => CCW,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub enum StencilOp {
|
|
Keep,
|
|
Zero,
|
|
Replace,
|
|
Incr,
|
|
Decr,
|
|
Invert,
|
|
IncrWrap,
|
|
DecrWrap,
|
|
}
|
|
|
|
impl From <StencilOp> for u32 {
|
|
fn from (v: StencilOp) -> Self {
|
|
use StencilOp::*;
|
|
{
|
|
use gl::*;
|
|
match v {
|
|
Keep => KEEP,
|
|
Zero => ZERO,
|
|
Replace => REPLACE,
|
|
Incr => INCR,
|
|
Decr => DECR,
|
|
Invert => INVERT,
|
|
IncrWrap => INCR_WRAP,
|
|
DecrWrap => DECR_WRAP,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub enum StencilFunc {
|
|
Never,
|
|
Always,
|
|
Less,
|
|
LessEqual,
|
|
Equal,
|
|
Greater,
|
|
GreaterEqual,
|
|
NotEqual,
|
|
}
|
|
|
|
impl From <StencilFunc> for u32 {
|
|
fn from (v: StencilFunc) -> Self {
|
|
use StencilFunc::*;
|
|
{
|
|
use gl::*;
|
|
match v {
|
|
Never => NEVER,
|
|
Always => ALWAYS,
|
|
Less => LESS,
|
|
LessEqual => LEQUAL,
|
|
Equal => EQUAL,
|
|
Greater => GREATER,
|
|
GreaterEqual => GEQUAL,
|
|
NotEqual => NOTEQUAL,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub enum DepthFunc {
|
|
Never,
|
|
Always,
|
|
Less,
|
|
LessEqual,
|
|
Equal,
|
|
Greater,
|
|
GreaterEqual,
|
|
NotEqual,
|
|
}
|
|
|
|
impl From <DepthFunc> for u32 {
|
|
fn from (v: DepthFunc) -> Self {
|
|
use DepthFunc::*;
|
|
{
|
|
use gl::*;
|
|
match v {
|
|
Never => NEVER,
|
|
Always => ALWAYS,
|
|
Less => LESS,
|
|
LessEqual => LEQUAL,
|
|
Equal => EQUAL,
|
|
Greater => GREATER,
|
|
GreaterEqual => GEQUAL,
|
|
NotEqual => NOTEQUAL,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub struct StencilOpState {
|
|
pub sfail: StencilOp,
|
|
pub dpfail: StencilOp,
|
|
pub dppass: StencilOp,
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub struct StencilFuncState {
|
|
pub func: StencilFunc,
|
|
pub reference: i32,
|
|
pub mask: u32,
|
|
}
|
|
|
|
#[derive (Copy, Clone, PartialEq, Eq)]
|
|
pub struct StencilState {
|
|
pub op: StencilOpState,
|
|
pub func: StencilFuncState,
|
|
}
|
|
|
|
// These are POD where no extra data is needed
|
|
// to safely use the flags / numbers
|
|
|
|
#[derive (Clone)]
|
|
pub struct IsoGlState {
|
|
pub shader_id: Option <u32>,
|
|
|
|
pub flags: HashMap <u32, bool>,
|
|
pub front_face: Option <FrontFace>,
|
|
pub stencil: Option <StencilState>,
|
|
pub depth_func: Option <DepthFunc>,
|
|
|
|
pub color_mask: Option <[u8; 4]>,
|
|
pub depth_mask: Option <u8>,
|
|
pub stencil_mask: Option <u32>,
|
|
}
|
|
|
|
impl Default for IsoGlState {
|
|
fn default () -> Self {
|
|
Self {
|
|
shader_id: None,
|
|
flags: hashmap! {},
|
|
front_face: None,
|
|
stencil: None,
|
|
depth_func: None,
|
|
color_mask: None,
|
|
depth_mask: None,
|
|
stencil_mask: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
// These are POD IDs or hashes of non-POD data
|
|
|
|
pub struct NonIsoGlState {
|
|
}
|
|
|
|
impl Default for NonIsoGlState {
|
|
fn default () -> Self {
|
|
Self {
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct GlState {
|
|
pub iso: IsoGlState,
|
|
pub non_iso: NonIsoGlState,
|
|
}
|
|
|
|
impl std::default::Default for GlState {
|
|
fn default () -> Self {
|
|
Self {
|
|
iso: Default::default (),
|
|
non_iso: Default::default (),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive (Clone, Default)]
|
|
pub struct Pass {
|
|
// In the context of a Pass, "None" means "Don't care"
|
|
|
|
pub iso: IsoGlState,
|
|
}
|
|
|
|
// Builder methods
|
|
|
|
impl Pass {
|
|
pub fn shader (&mut self, x: &crate::shader_closure::ShaderClosure) -> &mut Self {
|
|
self.iso.shader_id = Some (x.get_id ());
|
|
self
|
|
}
|
|
|
|
pub fn shader_id <T: Into <Option <u32>>> (&mut self, x: T) -> &mut Self {
|
|
self.iso.shader_id = x.into ();
|
|
self
|
|
}
|
|
|
|
pub fn color_mask <T: Into <Option <[u8; 4]>>> (&mut self, x: T) -> &mut Self {
|
|
self.iso.color_mask = x.into ();
|
|
self
|
|
}
|
|
|
|
pub fn depth_mask <T: Into <Option <u8>>> (&mut self, x: T) -> &mut Self {
|
|
self.iso.depth_mask = x.into ();
|
|
self
|
|
}
|
|
|
|
pub fn stencil_mask <T: Into <Option <u32>>> (&mut self, x: T) -> &mut Self {
|
|
self.iso.stencil_mask = x.into ();
|
|
self
|
|
}
|
|
|
|
pub fn flag (&mut self, k: u32, v: bool) -> &mut Self {
|
|
self.iso.flags.insert (k, v);
|
|
self
|
|
}
|
|
|
|
pub fn flags <I: Iterator <Item=(u32, bool)>> (&mut self, i: I) -> &mut Self {
|
|
for (k, v) in i {
|
|
self.flag (k, v);
|
|
}
|
|
self
|
|
}
|
|
|
|
pub fn front_face <T: Into <Option <FrontFace>>> (&mut self, x: T) -> &mut Self {
|
|
self.iso.front_face = x.into ();
|
|
self
|
|
}
|
|
}
|
|
|
|
// State-diffing stuff
|
|
|
|
impl Pass {
|
|
pub fn apply_diff (&self, old_state: &mut IsoGlState) {
|
|
let state = &self.iso;
|
|
|
|
let mut flag_elision_count = 0;
|
|
|
|
for (flag, value) in state.flags.iter () {
|
|
let old_entry = old_state.flags.entry (*flag);
|
|
|
|
if match &old_entry {
|
|
hash_map::Entry::Vacant (_) => true,
|
|
hash_map::Entry::Occupied (o) => o.get () != value,
|
|
} {
|
|
if *value {
|
|
glezz::enable (*flag);
|
|
}
|
|
else {
|
|
glezz::disable (*flag);
|
|
}
|
|
|
|
(*old_entry.or_insert (*value)) = *value;
|
|
}
|
|
else {
|
|
flag_elision_count += 1;
|
|
}
|
|
}
|
|
if flag_elision_count > 0 {
|
|
//println! ("Elided {} flags", flag_elision_count);
|
|
}
|
|
|
|
if let Some (v) = &state.front_face {
|
|
if old_state.front_face != state.front_face {
|
|
glezz::front_face ((*v).into ());
|
|
old_state.front_face = state.front_face;
|
|
}
|
|
else {
|
|
//println! ("Elided front_face ()");
|
|
}
|
|
}
|
|
|
|
if let Some (v) = &state.stencil {
|
|
if old_state.stencil != state.stencil {
|
|
let func = &v.func;
|
|
unsafe {
|
|
gl::StencilFunc (
|
|
func.func.into (),
|
|
func.reference.into (),
|
|
func.mask.into ()
|
|
);
|
|
}
|
|
|
|
let op = &v.op;
|
|
unsafe {
|
|
gl::StencilOp (
|
|
op.sfail.into (),
|
|
op.dpfail.into (),
|
|
op.dppass.into ()
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
//println! ("Elided stencil state");
|
|
}
|
|
}
|
|
|
|
if let Some (v) = &state.depth_func {
|
|
if old_state.depth_func != state.depth_func {
|
|
glezz::depth_func ((*v).into ());
|
|
old_state.depth_func = state.depth_func;
|
|
}
|
|
else {
|
|
//println! ("Elided depth_func ()");
|
|
}
|
|
}
|
|
|
|
if let Some ([r, g, b, a]) = &state.color_mask {
|
|
if old_state.color_mask != state.color_mask {
|
|
glezz::color_mask (*r, *g, *b, *a);
|
|
old_state.color_mask = state.color_mask;
|
|
}
|
|
else {
|
|
//println! ("Elided color_mask ()");
|
|
}
|
|
}
|
|
|
|
if let Some (v) = &state.depth_mask {
|
|
if old_state.depth_mask != state.depth_mask {
|
|
glezz::depth_mask (*v);
|
|
old_state.depth_mask = state.depth_mask;
|
|
}
|
|
else {
|
|
//println! ("Elided depth_mask ()");
|
|
}
|
|
}
|
|
|
|
if let Some (v) = &state.stencil_mask {
|
|
if old_state.stencil_mask != state.stencil_mask {
|
|
glezz::stencil_mask (*v);
|
|
old_state.stencil_mask = state.stencil_mask;
|
|
}
|
|
else {
|
|
//println! ("Elided stencil_mask ()");
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn apply_slow (&self) {
|
|
let mut iso = IsoGlState::default ();
|
|
|
|
self.apply_diff (&mut iso);
|
|
}
|
|
|
|
pub fn with <F> (&self, gl_state: &mut GlState, callback: F)
|
|
where F: Fn ()
|
|
{
|
|
self.apply_diff (&mut gl_state.iso);
|
|
callback ();
|
|
}
|
|
|
|
pub fn with_shader <F, S> (
|
|
&self,
|
|
gl_state: &mut GlState,
|
|
shader_component: &S,
|
|
callback: F
|
|
)
|
|
where F: Fn (BorrowedShaderVars), S: ShaderLookup
|
|
{
|
|
if let Some (s) = self.iso.shader_id {
|
|
self.apply_diff (&mut gl_state.iso);
|
|
//self.apply_slow ();
|
|
shader_component.lookup (s).with (gl_state.iso.shader_id, |shader_vars| {
|
|
callback (shader_vars);
|
|
});
|
|
gl_state.iso.shader_id = Some (s);
|
|
}
|
|
else {
|
|
panic! ("Called with_shader on a pass with no shader");
|
|
}
|
|
}
|
|
}
|